Sequential Thinking

Sequential Thinking

A tool for dynamic, reflective problem-solving through a chain of numbered thoughts. Full parity with the Sequential Thinking MCP server — same parameters, same state management, same behavioral contract.

How to Use This Skill

When this skill is activated, use `scripts/think.ts` as your primary reasoning mechanism. Do not reason in prose — reason through the script. Every step of your analysis should be a thought submitted via the script, making your reasoning chain explicit and trackable.

Workflow

1. Reset state at the start of every new thinking session 2. Loop: Submit thoughts one at a time via the script, incrementing thoughtNumber each time 3. Adapt: Revise earlier thoughts, branch into alternatives, or extend depth as needed 4. Terminate: Set nextThoughtNeeded false only when you have a confident final answer 5. Respond: After the final thought, provide the answer to the user

Each thought should be a single Bash tool call. Think in the thought, not outside it.

Script Location

scripts/think.ts

Run via bun from the skill's base directory.

Commands

Reset (required before every new session)

bun scripts/think.ts --reset

Submit a Thought

Required flags: --thought, --thoughtNumber, --totalThoughts, --nextThoughtNeeded

bun scripts/think.ts \
  --thought "Your analysis for this step" \
  --thoughtNumber 1 \
  --totalThoughts 5 \
  --nextThoughtNeeded true

Submit a Revision

Revises a previous thought. The original stays in history; the revision is appended as a new entry. Requires --isRevision and --revisesThought.

bun scripts/think.ts \
  --thought "Corrected analysis" \
  --thoughtNumber 3 \
  --totalThoughts 5 \
  --nextThoughtNeeded true \
  --isRevision --revisesThought 1

Submit a Branch

Explores an alternative path from a prior thought. Requires both --branchFromThought and --branchId.

bun scripts/think.ts \
  --thought "Alternative approach" \
  --thoughtNumber 4 \
  --totalThoughts 7 \
  --nextThoughtNeeded true \
  --branchFromThought 2 --branchId alt-approach

Extend Depth

Signal that more thoughts are needed beyond the original estimate.

bun scripts/think.ts \
  --thought "Scope is larger than expected" \
  --thoughtNumber 6 \
  --totalThoughts 8 \
  --nextThoughtNeeded true \
  --needsMoreThoughts

Inspect Full State

bun scripts/think.ts --status

Returns JSON with fullHistory and branchDetails.

Output Format

Each thought invocation prints the thought to stderr and a compact status line to stdout:

💭 Thought 3/7
The analysis shows that...
[3/7] history=3 next=true

Revision and branch thoughts use 🔄 Revision and 🌿 Branch headers respectively.

Parameters (Full MCP Parity)

Behavioral Rules

These match the MCP server's tool description exactly:

1. Start with an initial estimate of totalThoughts, but adjust freely as understanding deepens 2. Auto-adjust: If thoughtNumber exceeds totalThoughts, the script raises totalThoughts to match 3. Revise previous thoughts when you realize an earlier step was wrong or incomplete — set --isRevision and --revisesThought N. The original stays in history; the revision is appended 4. Branch to explore alternative reasoning paths — set both --branchFromThought N and --branchId label. This does not abandon the main line 5. Extend beyond the initial estimate at any time with --needsMoreThoughts and an increased --totalThoughts 6. Express uncertainty — not every thought needs confidence. Questioning and exploring is encouraged 7. Filter noise — ignore information irrelevant to the current step 8. Generate hypotheses when you have enough evidence, then verify them against prior thoughts in the chain 9. Iterate hypothesis-verification cycles until satisfied with the answer 10. Terminate only when you have a satisfactory answer — set --nextThoughtNeeded false 11. Non-linear paths are first-class — branching, backtracking, and revision are features, not failures

State Management

• State is persisted to scripts/.think_state.json between invocations
• thoughtHistory[] is append-only — thoughts are never deleted
• branches{} maps branch IDs to their thought arrays
• --reset clears all state for a fresh session
• --status dumps the full state as JSON for inspection

Example Session

See references/example-session.md for a complete worked example demonstrating normal thoughts, revisions, branches, and dynamic depth adjustment.

Example Session: "What is the optimal strategy for a 3-player auction?"

Thought 1 — Initial framing

💭 Thought 1/5
First, I need to clarify what type of auction we're dealing with.
Common types: English (ascending), Dutch (descending), sealed-bid
first-price, sealed-bid second-price (Vickrey). The optimal strategy
differs significantly by type. I'll assume a sealed-bid first-price
auction unless told otherwise.
[1/5] history=1 next=true

Thought 2 — Core analysis

💭 Thought 2/5
In a sealed-bid first-price auction with 3 players and independent
private values uniformly distributed on [0,1], the symmetric Bayesian
Nash equilibrium bidding strategy is b(v) = v * (n-1)/n = v * 2/3.
Each player shades their bid below their true valuation.
[2/5] history=2 next=true

Thought 3 — Revision of thought 1

🔄 Revision 3/5 (revising thought 1)
Wait — I assumed sealed-bid first-price, but the question says
"auction" generically. I should cover the dominant strategy for
the most common types rather than assuming one. This changes my
approach: I need to address multiple formats.
[3/5] history=3 next=true

Thought 4 — Branching to explore Vickrey auction

totalThoughts adjusted upward from 5 to 7 because the revision revealed more ground to cover.

🌿 Branch 4/7 (from thought 2, ID: vickrey)
In a Vickrey (second-price sealed-bid) auction, the dominant strategy
is to bid your true valuation regardless of the number of players.
With 3 players, each bids v. The winner pays the second-highest bid.
This is strategy-proof: no player benefits from deviating.
[4/7] history=4 branches=vickrey next=true

Thought 5 — Branching to explore English auction

🌿 Branch 5/7 (from thought 2, ID: english)
In an English (ascending) auction with 3 players, the dominant
strategy is to stay in the bidding until the price reaches your
valuation, then drop out. The winner is the last remaining bidder,
paying just above the second-highest valuation. Strategically
equivalent to the Vickrey auction.
[5/7] history=5 branches=vickrey,english next=true

Thought 6 — Hypothesis generation

💭 Thought 6/7
Hypothesis: The optimal strategy depends entirely on auction format.
For 3 players: First-price sealed → bid 2/3 of value.
Vickrey/English → bid true value. Dutch → equivalent to first-price.
Let me verify this against the revenue equivalence theorem before
concluding.
[6/7] history=6 branches=vickrey,english next=true

Thought 7 — Verification and final answer

💭 Thought 7/7
Verification: Revenue equivalence theorem confirms all four standard
auction formats yield the same expected revenue under symmetric
independent private values. The strategies:

• First-price sealed / Dutch: bid (n-1)/n × value = 2/3v
• Second-price sealed / English: bid true value = v

Both are equilibrium strategies. The 3-player case doesn't introduce
special considerations beyond the general n-player formulas.
Final answer confirmed.
[7/7] history=7 branches=vickrey,english next=false

Key Features Demonstrated

• Dynamic depth: Started at 5, expanded to 7 when scope grew
• Revision: Thought 3 reconsidered the assumption made in thought 1
• Branching: Thoughts 4 and 5 explored alternative auction types from thought 2
• Hypothesis + verification: Thought 6 proposed, thought 7 verified
• Clean termination: nextThoughtNeeded: false only after confident answer