do-think（确实认为）

Do Think

The deep-thinking skill. Use it when acting on the first plausible answer is risky.

Two operating modes:

• Solo deep-think (default) — agent reasons alone, then acts.
• Interactive brainstorm — user in the loop, 5 forks, 6-step structured session.

One core loop applies to both. Pick the mode FIRST, then run the loop.

Trigger boundary

Use this skill when:

• the problem is underspecified
• the root cause is unknown
• multiple approaches are viable and tradeoffs matter
• a refactor could change behavior, boundaries, or workflow
• the codebase or domain is unfamiliar
• the change is expensive to reverse
• the task is likely to derail if you stop after the first obstacle
• the user explicitly asked to brainstorm, walk through, or think together

Do NOT use this skill when:

• the task is trivial, mechanical, or fully specified
• the user gave exact steps and the main risk is execution, not reasoning
• you are only summarizing, translating, or relaying already-known facts
• the task is a runtime bug with a reproducible failure → use do-debug instead
• the task is verifying what's actually done vs. claimed → use check-completion

Pick a mode FIRST (Iron Law #0)

Default: Solo. Switch to Interactive when any of:

• The user said "help me think", "walk through", "brainstorm", "let's figure out", "let's explore"
• The user is present AND the decision is high-stakes / hard-to-reverse
• ≥2 viable options have no obvious winner AND the user is reachable
• Solo's Phase C2 stress-test killed all three options (escalation gate)
• The decision requires the user's domain knowledge or stakeholder context

Cross-runtime note: Interactive needs an ask-user tool. See references/cross-runtime.md for the runtime → tool lookup and the prose fallback. Do not silently degrade Interactive into Solo — surface the limitation if the runtime can't support forks.

The opening contract (Iron Law #1)

The first line of every response is a single machine-checkable contract:

Mode: <Solo|Interactive>   Op: <op>   Cynefin: <Clear|Complicated|Complex|Chaotic|Disorder>   Tier: <Low|Medium|High>

Where Op is one of: SenseMaking | Extraction | Composition | Reshape | GroundedQA | WatchTrigger | Orchestration | SelfVerify.

This line is non-skippable. It declares mode (no silent default-to-Solo), proves Phase A1 ran (no skipping the Cynefin classifier), proves Phase A2 ran (no defaulting to Sense-Making for everything), and locks the effort tier (no scope creep). The user can correct any of four things in one re-prompt. Re-emit if any field changes mid-session.

Non-negotiable rules

1. Iron Laws #0 + #1 are mandatory. Mode picked, opening contract emitted (with Op + Cynefin + Tier), on the first response.
2. Ground before hypothesis.
3. Match effort to Tier — references/foundations/effort-calibration.md governs reading depth and stress-test strictness.
4. Match thinking tools to Op — references/foundations/operation-classification.md governs which Phase C1/C2 tools fit. The stress-test trio fits Sense-Making; other operations have their own stress-test focus.
5. Keep ≥3 live options through Phase C *only when Op = SenseMaking*. Other operations have operation-specific C1 outputs (filled schemas for Extraction, outlines for Composition, retrieved evidence for GroundedQA, etc.).
6. Stress-test before commit at Tier Medium or High. The trio is for SenseMaking; see operation-classification.md for the per-op stress-test focus.
7. Separate observations, mechanisms, and judgments at every phase.
8. Numbered, stepwise progress instead of mental jumps.
9. Prefer the smallest next move that changes your certainty.
10. End every session with a concrete next move + verification check (shape varies by Op).
11. Foundations are self-sufficient. frameworks/ is library — accessed only via the master routing table at the bottom of this file or by modes/interactive-brainstorm.md. Do not cross-link from foundations to frameworks.

The universal core loop — 4 phases

Phase A — Frame      A1 classify domain   ·   A2 classify operation   ·   A3 reframe (if needed)
Phase B — Calibrate  B1 effort tier       ·   B2 minimum grounding (op-aware)
Phase C — Compare    C1 op-specific output ·  C2 op-specific stress-test
Phase D — Commit     D1 choose / produce  ·   D2 verify (op-specific)

Phase A — Frame

• A1. Classify the domain (Cynefin) → references/foundations/domain-classification.md. Write the domain in the opening contract.
• A2. Classify the operation (8 cognitive operations) → references/foundations/operation-classification.md. Write the operation in the opening contract. This is what selects the rest of Phase B and all of Phase C.
• A3. Reframe the real question. Default: skip. Reframe only if A1 returned Disorder, OR the user's framing fails the why-up test → references/foundations/reframing.md (Abstraction Laddering).

Phase A exit: opening contract written (4 fields); reframe done if needed.

Phase B — Calibrate

• B1. Effort tier (Hard Choice × Confidence-vs-Quality) → references/foundations/effort-calibration.md. Output: Low / Medium / High in the opening contract.
• B2. Gather the minimum grounding set — shape varies by Op (see operation-classification.md):

- SenseMaking: direct observation + primary docs (evidence ladder) - Extraction: schema spec + sample inputs (≥3 covering edges) - Composition: form examples + voice spec + factual context + audience - Reshape: invariants + scope of change - GroundedQA: corpus boundary + retrieved passages - WatchTrigger: trigger conditions + signal definition + history baseline - Orchestration: system contracts + idempotency keys + error modes - SelfVerify: oracle definition + iteration budget + convergence criterion

Phase B exit: tier set; minimum evidence (op-shaped) collected.

Phase C — Compare

C1 and C2 are operation-specific. The 4-phase loop is universal; what each phase produces depends on the operation. Run the workflow for the classified Op.

• C1. Op-specific output (NOT always "≥3 options"):

- SenseMaking → ≥3 candidate verdicts with falsifiers - Extraction → filled schema + completeness flag + ambiguity log - Composition → outline + assumption list (≥3 outline variants only when structural choice matters) - Reshape → transformation plan + invariant proofs - GroundedQA → retrieved evidence + scope confirmation - WatchTrigger → trigger spec + alert payload + escalation rules - Orchestration → sequence + idempotency markers + error handlers - SelfVerify → first attempt + first oracle reading

• C2. Op-specific stress-test (mandatory at Tier Medium/High):

- SenseMaking → Inversion + Ladder of Inference + Second-Order (the trio) → references/foundations/stress-test-trio.md - Extraction → coverage + edge case + schema-fit - Composition → form-substance match + voice fit + audience appropriateness - Reshape → behavior preservation + scope-creep check - GroundedQA → hallucination scan + citation completeness + out-of-scope flag - WatchTrigger → false-positive scan + missed-signal scan + signal/noise - Orchestration → partial-failure scan + transaction boundary check + retry safety - SelfVerify → loop bound + oracle accuracy + escape condition

Phase C exit criterion: op-specific C1 output written AND op-specific C2 stress-test written. Outputs are written, not implied.

Escalation gate: if C2 kills all options/candidates/attempts, switch Mode to Interactive — do not silently pick the least-bad option.

Phase D — Commit

• D1. Choose the next move (op-shaped): implement / produce / probe / ask one clarifying question / stop.
• D2. Verify or revise — every chosen path needs a verification check + a revision trigger. Shape varies by Op (verdict observation for SenseMaking; schema validator pass for Extraction; audience decision for Composition; oracle pass for SelfVerify; etc.).

Phase D exit: chosen path stated; verification check (op-shaped) written.

Solo mode — fast routing

Read the smallest set that fits the situation. Files listed are the *minimum*; add foundations as Tier escalates.

Interactive mode — 6-step session, 5 forks

Full spec at references/modes/interactive-brainstorm.md. The 4-phase loop maps to a 6-step session with 5 forks:

Skip-fork policy and one-question-at-a-time discipline live in references/interaction-patterns.md.

Output contract

• Solo mode — Minto Pyramid:

- First sentence = chosen path - Body = 3-5 evidence-backed key arguments - Last sentence = verification check - Fast-fail: missing first sentence OR last sentence = output incomplete

• Interactive mode — 10-section contract: Approach / Problem shape / Decomposition / Options explored / Evaluation / Assumptions / Blind spots / Second-order effects / Ranked summary / Recommended next step

Full spec: references/foundations/output-contract.md.

Anti-patterns

• Acting on the first plausible explanation
• Skipping Phase A1 (Cynefin) because the prompt feels straightforward
• Skipping Phase A2 (Op classification) and defaulting to Sense-Making for everything
• Running the Sense-Making stress-test trio on a non-Sense-Making operation
• Forcing ≥3 options on a task that isn't Sense-Making (Extraction wants completeness, Composition wants outline-fit)
• Letting one attractive option kill comparison too early (in Sense-Making)
• Treating Phase C2 stress-test as ceremonial when it's load-bearing
• Stopping after the first obstacle when better local moves still exist
• Claiming success before stating the (op-shaped) verification result
• Silently degrading Interactive into Solo
• Reading frameworks/* without being routed there from this master table or from modes/interactive-brainstorm.md
• Asking the user a clarifying question mid-Solo (you've hit an escalation trigger — switch to Interactive instead)

Anti-rationalization table

Voice discipline

Required forms (use these literally in output):

• Mode: <Solo|Interactive>
• Op: <SenseMaking|Extraction|Composition|Reshape|GroundedQA|WatchTrigger|Orchestration|SelfVerify>
• Cynefin: <domain>
• Tier: <Low|Medium|High>
• Live options: 1) … 2) … 3) … (in C1, *only* when Op = SenseMaking)
• Filled schema: / Outline: / Retrieved evidence: / Trigger spec: / Sequence: / Oracle reading: (in C1, op-specific)
• Pre-mortem failure mode: … (in C2, *only* when Op = SenseMaking)
• Coverage: … / Form-substance match: … / Hallucination scan: … / etc. (in C2, op-specific)
• Verification check: … (in D2)

Forbidden phrases:

• "I think the best option is…" (without three named options)
• "this is straightforward" (without a Cynefin check)
• "let me know if you want me to dig deeper" (false abdication)
• "Thanks for the great discussion" / "Hope this helps" / "Please feel free to" / "You're absolutely right" (shared with the pack's review skills)

Escalation gates

• Solo → Interactive when: 3 candidate options die in stress-test
• Interactive → Solo never silently — only on explicit user request
• Out to do-debug when: the task is a runtime bug with a reproducible failure
• Out to check-completion when: declared "done" but unsure what's actually verified
• Do NOT recommend do-think as the next-step (no infinite regress). If more thinking is needed, name the sub-topic and explicitly hand off.

Reference routing — master table

Foundations are self-sufficient (read directly when the loop says so). frameworks/ is library — accessed only via the rows below or via modes/interactive-brainstorm.md. Do not cross-link foundations into frameworks.

Foundations (load-bearing primitives, used by every session)

Modes (how the skill operates)

Workflows (operation-specific recipes)

Frameworks (library — accessed only from this table or from Interactive Steps 2-5)

Cross-cutting (Interactive mode infrastructure)

Final test

Before you act, ask:

*Do I know enough to make the next move safer and clearer than acting immediately would be?*

If yes, act. If no, gather the smallest missing evidence first.