reasoning-router（推理路由器）

Reasoning Router

Meta-reasoning layer: classify problems, dispatch to the optimal thinking MCP, monitor progress, re-route on stall. Minimize total tokens to a high-confidence conclusion.

Always uses the most advanced model (currently Opus 4.6). Meta-reasoning about *how to think* is the highest-leverage reasoning task.

Dispatch

Classification

Run !uv run python skills/reasoning-router/scripts/problem-classifier.py "$ARGUMENTS" for deterministic pre-scan, then refine with LLM judgment.

Axis 1 — Structure (what shape is the reasoning?)

Axis 2 — Complexity (how deep?)

Axis 3 — Domain (what kind?)

Routing Algorithm

Optimize for minimum total tokens to reach a high-confidence conclusion.

1. Run problem-classifier.py for deterministic signals
2. Score each axis (structure × complexity × domain)
3. Apply efficiency gate:
   - Simple: ALWAYS Tier 1 (aot-light or sequential-thinking)
   - Moderate: structure-matched method at default depth
   - Complex: full method with extended depth
   - Wicked: composition patterns allowed
4. Resolve conflicts:
   - Structure > domain (HOW > WHAT)
   - Complexity modulates depth AND tier
   - Ties: ALWAYS prefer lower token cost
5. Select primary + fallback
6. Present: "Using [method] — [why]. Fallback: [method]." (1 line)
7. Invoke with minimum viable totalThoughts
8. Monitor for stalls — escalate only on evidence

Token Cost Tiers

Tier 1 (lightest): aot-light, sequential-thinking
Tier 2 (moderate): structured-thinking, cascade-thinking, crash
Tier 3 (heavy):    shannon-thinking, atom-of-thoughts (full), think-strategies
Tier 4 (heaviest): creative-thinking, deep-lucid-3d, lotus-wisdom

Efficiency Rules

• Never Tier 3-4 for a problem Tier 1-2 can handle
• Start with lowest viable totalThoughts; expand only on needsMoreThoughts
• cascade-thinking: start 2 branches max; add only if coverage insufficient
• creative-thinking: use timeframe: "quick" unless wicked
• think-strategies: start with linear or chain_of_thought before heavier strategies

Stall Detection

Read references/stall-detection.md when any stall signal fires.

4 stall signals:

1. Confidence plateau — no increase >0.05 in 3+ steps
2. Circular reasoning — same claim restated
3. Step overrun — exceeds 2× initial estimate
4. User signal — "try something else" or /think switch

Re-routing by block type:

Hard limits: Max 3 re-routes per session. Max 3× step estimate. No ping-pong (can't return to a method already re-routed from). After 3 re-routes → recovery protocol: present findings, ask user to guide.

Composition Patterns

Read references/composition-patterns.md for full protocols.

Context transfer: At every method transition, produce ≤100 word summary of key findings with confidence scores. Carry claims, drop scaffolding.

When NOT to compose: Simple/moderate complexity, first method is converging, time pressure is high.

Compare Mode

When invoked with compare <problem>:

1. Classify the problem normally
2. Select 2-3 candidate methods (primary + 1-2 plausible alternatives)
3. Run each for 3-5 steps on the same problem
4. Compare: which produced higher-confidence findings with fewer tokens?
5. Present comparison table and recommend the winner
6. Continue with the winning method if user agrees

Methods Quick Reference

When invoked with methods or for the routing cheatsheet:

Read references/capability-map.md for full tool parameters and workflows.

Reference File Index

Load ONE reference at a time. Do not preload.

Scope Boundaries

In scope: Problem classification, thinking MCP dispatch, stall detection, re-routing, composition pattern selection, method comparison.

Out of scope: Actually performing the reasoning (the thinking MCP does that), running tools or writing code (use appropriate skills), code review (honest-review), research (research), debugging implementation (use crash MCP directly).

Canonical Vocabulary

Critical Rules

1. Always use the most advanced model — model: opus. Never downgrade.
2. Minimize total tokens to conclusion — pick the lightest method that handles the problem. Escalate only on evidence of stall.
3. Present routing decision before invoking — 1 line: method, why, fallback.
4. Never invoke without classification — even if user names a method, validate fit.
5. Carry forward on re-route — summarize findings ≤100 words, don't restart.
6. Simple gets simple — Tier 1 for simple problems, always. No exceptions.
7. Token cost breaks ties — equal fit → lower tier wins.
8. Start minimal, expand on evidence — lowest totalThoughts, expand only when the tool requests more or stall detected.
9. One method at a time — no simultaneous thinking MCPs. Composition is sequential.
10. Router ≠ thinker — classify, dispatch, monitor. Don't duplicate reasoning.
11. Respect tool workflows — creative-thinking: discover→plan→execute. lotus-wisdom: start with tag: begin. aot: use atomcommands for control.
12. Track token spend — note approximate tokens per session to refine routing.