pan-wizard 2.8.1 → 2.9.1

package/commands/pan/map-codebase.md

@@ -49,16 +49,42 @@ Check for .planning/state.md - loads context if project already initialized
 - Trivial codebases (<5 files)
 </when_to_use>
 
+<tool_priority>
+Each mapper agent should use the simplest sufficient tool:
+1. Glob — discover files by pattern (find all .ts files, config files, test files)
+2. Grep — search for patterns across the codebase (imports, exports, function names)
+3. Read — examine specific files found by Glob/Grep
+4. Bash — only for git history or commands dedicated tools cannot handle
+</tool_priority>
+
+<progressive_context>
+The orchestrator loads context in layers — NOT everything upfront. Mapper agents receive only what they need.
+
+**Orchestrator layers (before spawning agents):**
+1. **Manifest** — package.json/Cargo.toml, project identity, entry points
+2. **Structure** — top-level directory listing, file count by extension, test presence
+3. **Git summary** — recent commits (10), contributors, branch info
+
+**Per-agent context (each agent loads its own):**
+- Each agent starts with: project manifest + directory structure + its focus area description
+- Each agent discovers its own details via Glob/Grep/Read within its focus area
+- Agents do NOT receive other agents' output (parallel, independent)
+
+**Why:** Loading the entire codebase into the orchestrator before spawning agents wastes orchestrator context. Each agent has a fresh 200k window — let them explore independently. The orchestrator only needs enough context to spawn correctly and verify outputs exist.
+</progressive_context>
+
 <process>
 1. Check if .planning/codebase/ already exists (offer to refresh or skip)
 2. Create .planning/codebase/ directory structure
-3. Spawn 4 parallel pan-document_code agents:
-   - Agent 1: tech focus → writes STACK.md, INTEGRATIONS.md
-   - Agent 2: arch focus → writes ARCHITECTURE.md, STRUCTURE.md
-   - Agent 3: quality focus → writes CONVENTIONS.md, TESTING.md
-   - Agent 4: concerns focus → writes CONCERNS.md
+3. Spawn 6 parallel pan-document_code agents:
+   - Agent 1: tech focus → writes stack.md, integrations.md
+   - Agent 2: arch focus → writes architecture.md, structure.md
+   - Agent 3: quality focus → writes conventions.md, testing.md
+   - Agent 4: concerns focus → writes concerns.md
+   - Agent 5: relationships focus → writes relationships.md
+   - Agent 6: practices focus → writes best-practices.md
 4. Wait for agents to complete, collect confirmations (NOT document contents)
-5. Verify all 7 documents exist with line counts
+5. Verify all 9 documents exist with line counts
 6. Commit codebase map
 7. Offer next steps (typically: /pan:new-project or /pan:plan-phase)
 </process>

package/commands/pan/milestone-audit.md

@@ -31,6 +31,29 @@ Glob: .planning/phases/*/*-summary.md
 Glob: .planning/phases/*/*-verification.md
 </context>
 
+<citation_requirement>
+Every coverage judgment in the audit MUST cite evidence from the codebase.
+
+**Before writing any requirement as "covered" or "not covered", verify by reading the code.**
+
+**Grounding rules:**
+- "Covered" requires: file:line where the requirement is implemented + verification.md or test evidence
+- "Partially covered" requires: file:line showing what exists + specific gap description with expected location
+- "Not covered" requires: grep showing the expected functionality doesn't exist (show the search and empty result)
+- Cross-phase integration claims require: file:line in phase A's output + file:line in phase B's consumer
+
+**Anti-pattern:**
+```
+BAD:  "Requirement R3 is covered — the billing module handles this"
+      → Which file? Which function? How do you know?
+GOOD: "Requirement R3 is covered — generateInvoice() at src/billing.ts:42 implements line-item
+       calculation. Verified in phase-2-verification.md (line 18). Integration: called from
+       src/api/orders.ts:156 (phase 3)."
+```
+
+Do not trust summary files at face value. If a verification.md says "all tests pass" but you haven't confirmed the test count, that claim is ungrounded. Spot-check at least 2 verification files by running the actual tests.
+</citation_requirement>
+
 <process>
 Execute the audit-milestone workflow from @~/.claude/pan-wizard-core/workflows/milestone-audit.md end-to-end.
 Preserve all workflow gates (scope determination, verification reading, integration check, requirements coverage, routing).

package/commands/pan/new-project.md

@@ -37,6 +37,70 @@ Initialize a new project through unified flow: questioning → research (optiona
 @~/.claude/pan-wizard-core/templates/requirements.md
 </execution_context>
 
+<progressive_context>
+Load context in layers — do NOT read everything upfront. Each layer builds on the previous.
+
+**Layer 1: Manifest (always load first)**
+- package.json / Cargo.toml / pyproject.toml — project identity, deps, scripts
+- .planning/ existence check — is this a fresh start or existing project?
+- README.md first 50 lines — what the project claims to be
+
+**Layer 2: Structure (load during questioning)**
+- Directory tree (Glob top-level patterns) — understand project shape
+- Entry points — main files, index files, server files
+- Test infrastructure — test framework, test directory
+
+**Layer 3: Hotspots (load during research, if research is enabled)**
+- Most-changed files (git log --name-only) — where active work happens
+- Largest files — complexity centers
+- Import graph roots — most-depended-on modules
+
+**Layer 4: Baselines (load only when generating requirements/roadmap)**
+- Test count + pass rate
+- Build status
+- Dependency audit (outdated, vulnerable)
+
+**Why layered:** Loading everything at Layer 1 wastes 40-60% of context on information not needed until later. For greenfield projects, Layers 3-4 are empty and should be skipped entirely.
+</progressive_context>
+
+<routing_decision_tree>
+Use this decision tree to select the correct path. Evaluate conditions top-to-bottom; take the FIRST match.
+
+```
+IF .planning/ already exists AND contains project.md:
+  → WARN: "Project already initialized. Use /pan:resume to continue."
+  → STOP (do not overwrite existing project)
+
+ELSE IF --auto flag AND @ reference document provided:
+  → ASK config questions only (commit_docs, model_profile)
+  → SKIP interactive questioning (use the @ document as project context)
+  → RUN research automatically
+  → GENERATE requirements from research + @ document
+  → GENERATE roadmap from requirements
+  → No further interaction until complete
+
+ELSE IF --auto flag WITHOUT @ reference:
+  → ERROR: "--auto requires an @ referenced idea document"
+  → STOP
+
+ELSE (interactive mode — default):
+  → RUN questioning flow (5-area deep questioning)
+  → ASK: "Should I research the domain ecosystem?" (Y/N)
+    → IF Y: spawn researchers → synthesize → continue
+    → IF N: skip research → continue
+  → PRESENT requirements for approval
+  → PRESENT roadmap for approval
+  → COMMIT if commit_docs=true
+```
+
+**Research routing:**
+```
+IF user says research: spawn pan-project-researcher agents
+IF user declines research: skip directly to requirements generation
+IF codebase already has substantial code: suggest skipping research (existing code IS the context)
+```
+</routing_decision_tree>
+
 <process>
 Execute the new-project workflow from @~/.claude/pan-wizard-core/workflows/new-project.md end-to-end.
 Preserve all workflow gates (validation, approvals, commits, routing).

package/commands/pan/pause.md

@@ -27,13 +27,54 @@ Routes to the pause-work workflow which handles:
 State and phase progress are gathered in-workflow with targeted reads.
 </context>
 
+<handoff_schema>
+The `.continue-here.md` file MUST contain ALL of the following sections. Missing sections cause resume failures.
+
+```yaml
+# Required fields for .continue-here.md
+session_id: "{date}-{slug}"           # Unique session identifier
+paused_at: "{ISO-8601 timestamp}"     # When work was paused
+phase: "{phase number and name}"      # Current phase being worked on
+plan: "{plan file path}"              # Which plan was active
+
+position:
+  last_completed_task: "{task ID}"    # Last task that was fully done
+  next_task: "{task ID}"              # What to do next
+  wave: "{wave number, if applicable}"
+
+progress:
+  tasks_done: [{id, title, status}]   # All completed tasks this session
+  tasks_remaining: [{id, title}]      # What's left in the plan
+  test_baseline: "{N passing}"        # Test count when session started
+  test_current: "{N passing}"         # Test count at pause time
+
+decisions:
+  - "{decision made and why}"         # Choices that affect remaining work
+
+blockers:
+  - "{blocker description}"           # Anything preventing progress
+
+context:
+  files_modified: ["{paths}"]         # Files changed this session
+  key_findings: ["{findings}"]        # Non-obvious discoveries
+  next_action: "{specific action}"    # Exact first step on resume
+```
+
+**Why every field matters:**
+- `position` → resume agent knows WHERE to start (not re-reading the whole plan)
+- `progress` → resume agent knows test baseline (detects regressions vs pre-existing)
+- `decisions` → resume agent won't re-debate settled questions
+- `blockers` → resume agent can flag to user immediately instead of rediscovering
+- `context.next_action` → resume agent's first action is productive, not exploratory
+</handoff_schema>
+
 <process>
 **Follow the pause-work workflow** from `@~/.claude/pan-wizard-core/workflows/pause.md`.
 
 The workflow handles all logic including:
 1. Phase directory detection
 2. State gathering with user clarifications
-3. Handoff file writing with timestamp
+3. Handoff file writing with timestamp — **using the schema from `<handoff_schema>`**
 4. Git commit
 5. Confirmation with resume instructions
 </process>

package/commands/pan/plan-phase.md

@@ -40,6 +40,90 @@ Phase number: $ARGUMENTS (optional — auto-detects next unplanned phase if omit
 Normalize phase input in step 2 before any directory lookups.
 </context>
 
+<reflexion_loop>
+During the plan-checker verification iteration:
+1. Read the plan-checker's critique carefully
+2. For each identified gap: verify it is a genuine gap by re-reading the relevant requirement
+3. Do not blindly accept all critiques — some may be false positives from missing context
+4. Revise the plan to address genuine gaps only
+5. Maximum 2 revision iterations (plan → check → revise → check → final)
+This prevents over-revision while ensuring real gaps are closed.
+</reflexion_loop>
+
+<completion_contract>
+Planning is complete when ALL conditions are met:
+1. At least one plan.md file created in the phase directory
+2. Plan-checker passed (or max 2 revision iterations exhausted with final approval)
+3. Each plan contains: objective, task breakdown with estimates, dependency ordering, and key file links
+4. Research.md exists (unless --skip-research was used)
+5. User presented with results and next-step options
+
+Planning FAILS if: phase not found in roadmap, or planner agent returns empty/malformed output after retries.
+</completion_contract>
+
+<common_mistakes>
+Avoid these planning anti-patterns:
+```
+BAD:  Plan has 25 tasks for a single phase → too granular, executor loses context
+GOOD: 5-8 tasks per plan, each with clear scope and testable outcome
+
+BAD:  Task says "Implement the feature" with no file links or acceptance criteria
+      → Executor guesses at scope, misses edge cases
+GOOD: Task says "Add retry logic to api/client.ts:fetchData() — 3 retries with exponential backoff, tested by tests/client.test.ts"
+
+BAD:  Plan-checker flags a gap → blindly add a task without re-reading the requirement
+      → False positive becomes unnecessary work
+GOOD: Re-read the requirement → confirm the gap is real → then add the task
+```
+</common_mistakes>
+
+<routing_decision_tree>
+Use this decision tree to select the correct path. Evaluate conditions top-to-bottom; take the FIRST match.
+
+```
+IF --gaps flag is set:
+  → SKIP research (gap closure uses verification.md instead)
+  → READ verification.md for the phase
+  → PLAN with gap context
+  → VERIFY (unless --skip-verify)
+
+ELSE IF --prd <file> flag is set:
+  → SKIP discuss-phase entirely
+  → PARSE PRD file into context.md
+  → SKIP research (PRD provides requirements)
+  → PLAN from parsed requirements
+  → VERIFY (unless --skip-verify)
+
+ELSE IF --skip-research flag is set:
+  → SKIP research
+  → PLAN directly (must have roadmap context)
+  → VERIFY (unless --skip-verify)
+
+ELSE IF research.md already exists AND --research NOT set:
+  → SKIP research (reuse existing)
+  → PLAN using existing research.md
+  → VERIFY (unless --skip-verify)
+
+ELSE (default path):
+  → RUN research (spawn pan-phase-researcher)
+  → PLAN from research results
+  → VERIFY (unless --skip-verify)
+```
+
+**Verification loop routing:**
+```
+IF --skip-verify:
+  → Present plan, done
+
+ELSE:
+  → Spawn pan-plan-checker
+  → IF checker PASSES: done
+  → IF checker finds gaps (iteration 1): revise plan, re-check
+  → IF checker finds gaps (iteration 2): final revision, present with caveats
+  → Max 2 revision iterations
+```
+</routing_decision_tree>
+
 <process>
 Execute the plan-phase workflow from @~/.claude/pan-wizard-core/workflows/plan-phase.md end-to-end.
 Preserve all workflow gates (validation, research, planning, verification loop, routing).

package/commands/pan/profile.md

@@ -32,5 +32,6 @@ The workflow handles all logic including:
 2. Config file ensuring
 3. Config reading and updating
 4. Model table generation from MODEL_PROFILES
-5. Confirmation display
+5. Cost estimation display (relative cost multiplier per profile)
+6. Confirmation display
 </process>

package/commands/pan/quick.md

@@ -39,4 +39,19 @@ Context files are resolved inside the workflow (`init quick`) and delegated via
 <process>
 Execute the quick workflow from @~/.claude/pan-wizard-core/workflows/quick.md end-to-end.
 Preserve all workflow gates (validation, task description, planning, execution, state updates, commits).
+
+**Scope Containment:**
+Implement only what was asked. Do not refactor surrounding code, add unrelated improvements, or create abstractions for one-time fixes.
+
+**State Intent Before Implementing:**
+Before coding, state: "I will modify [files], adding [what], to achieve [goal]."
+
+**Pre-Commit Verification Checklist — apply before the final commit:**
+1. Every modified file was read before editing
+2. `git diff --stat` contains only files related to the task
+3. Tests pass (run the project's test suite)
+4. Commit message accurately describes the verified change
+5. No secrets or credentials staged
+
+If any check fails: fix and re-verify before committing.
 </process>

package/commands/pan/resume.md

@@ -26,6 +26,66 @@ Routes to the resume-project workflow which handles:
 @~/.claude/pan-wizard-core/workflows/resume-project.md
 </execution_context>
 
+<handoff_consumption>
+When a `.continue-here.md` file exists, parse it as structured handoff data before presenting options.
+
+**Required extraction (in order):**
+1. `position.next_task` → This is the FIRST thing to tell the user
+2. `blockers` → If non-empty, surface BEFORE offering to continue
+3. `decisions` → Load into context so they are not re-debated
+4. `progress.test_baseline` + `progress.test_current` → Verify current test count matches `test_current` (detect drift since pause)
+5. `context.next_action` → Use as the default suggested action
+
+**Resume validation:**
+- If `test_current` at resume time differs from stored value → warn user: "Test count changed since pause ({stored} → {current}). Someone else may have committed."
+- If `position.next_task` references a task not in the plan → warn: plan may have been revised since pause
+- If `blockers` exist → present them and ask if resolved before continuing
+
+**Anti-pattern:**
+```
+BAD:  Resume reads .continue-here.md, ignores position, re-reads entire plan from scratch
+      → Wastes context on already-completed work, may re-implement done tasks
+GOOD: Resume extracts position.next_task, skips completed tasks, starts exactly where paused
+```
+</handoff_consumption>
+
+<routing_decision_tree>
+Use this decision tree to select the correct resumption path. Evaluate top-to-bottom; take the FIRST match.
+
+```
+IF .planning/ does not exist:
+  → "No project found. Run /pan:new-project to get started."
+  → STOP
+
+ELSE IF .continue-here.md exists:
+  → PARSE handoff file using <handoff_consumption> protocol
+  → PRESENT: position, blockers, next action
+  → ROUTE to the command that was paused (exec-phase, plan-phase, etc.)
+
+ELSE IF state.md exists AND has status "in_progress":
+  → FIND incomplete work: plans without summaries, phases mid-execution
+  → IF incomplete phase found:
+    → PRESENT phase status + what remains
+    → OFFER: continue execution (/pan:exec-phase) or verify (/pan:verify-phase)
+  → IF no incomplete work but active milestone:
+    → PRESENT milestone progress
+    → OFFER: next unplanned phase (/pan:plan-phase) or audit (/pan:milestone-audit)
+
+ELSE IF state.md exists AND has status "blocked":
+  → PRESENT blockers from state.md
+  → OFFER: debug (/pan:debug) or unblock manually
+
+ELSE IF state.md exists AND has status "completed":
+  → "Current milestone is complete. Run /pan:milestone-done or /pan:milestone-new."
+  → STOP
+
+ELSE (state.md missing or unreadable):
+  → ATTEMPT reconstruction from .planning/ artifacts
+  → IF reconstruction succeeds: re-enter tree above
+  → IF reconstruction fails: "State is corrupted. Run /pan:new-project or restore from git."
+```
+</routing_decision_tree>
+
 <process>
 **Follow the resume-project workflow** from `@~/.claude/pan-wizard-core/workflows/resume-project.md`.
 
@@ -33,9 +93,9 @@ The workflow handles all resumption logic including:
 
 1. Project existence verification
 2. state.md loading or reconstruction
-3. Checkpoint and incomplete work detection
+3. Checkpoint and incomplete work detection — **parse using `<handoff_consumption>` protocol**
 4. Visual status presentation
 5. Context-aware option offering (checks context.md before suggesting plan vs discuss)
-6. Routing to appropriate next command
+6. Routing to appropriate next command — **following `<routing_decision_tree>`**
 7. Session continuity updates
    </process>

package/commands/pan/verify-phase.md

@@ -33,6 +33,48 @@ Phase: $ARGUMENTS (optional)
 Context files are resolved inside the workflow (`init verify-work`) and delegated via `<files_to_read>` blocks.
 </context>
 
+<investigate_before_judging>
+Never claim a feature works or doesn't work without reading the implementation first.
+Before each verification judgment:
+1. Read the source file(s) that implement the feature
+2. Read the test file(s) that cover it
+3. Run the tests
+4. Only then state your assessment with file:line evidence
+Do not speculate about code you have not opened.
+</investigate_before_judging>
+
+<citation_requirement>
+Every verdict (PASS, PARTIAL, FAIL) MUST include at least one file:line citation as evidence.
+
+**Before writing any judgment, scan your draft for unsourced claims.** If you find an assertion without evidence, stop and gather it before continuing.
+
+Format: `verdict: PASS — feature works as specified (src/billing.ts:42, tests/billing.test.ts:18-35)`
+
+**Grounding rules:**
+- PASS requires: file:line where the feature is implemented + test file:line where it's verified
+- PARTIAL requires: file:line showing what works + description of what's missing with expected location
+- FAIL requires: file:line showing the defect OR absence (grep result showing the expected function/export doesn't exist)
+- "I checked and it's not there" is NOT evidence — show the grep command and its empty result
+
+**Anti-pattern:**
+```
+BAD:  "FAIL — the retry logic doesn't handle timeouts"
+      → No evidence. Maybe it does handle timeouts and you didn't read far enough.
+GOOD: "FAIL — retry logic at api/client.ts:67-89 catches ConnectionError but not TimeoutError.
+       Grep for 'TimeoutError' in api/: 0 matches. tests/client.test.ts has no timeout test cases."
+```
+</citation_requirement>
+
+<reflexion_loop>
+After initial verification of each requirement:
+1. Score each requirement: PASS / PARTIAL / FAIL
+2. For PARTIAL or FAIL: state specifically what is missing or broken
+3. Re-read the requirement text and the implementation — did you miss anything?
+4. Revise the score if the re-read reveals evidence you overlooked
+5. Report only final scores after this review cycle
+This prevents premature FAIL verdicts from incomplete investigation.
+</reflexion_loop>
+
 <process>
 Execute the verify-work workflow from @~/.claude/pan-wizard-core/workflows/verify-phase.md end-to-end.
 Preserve all workflow gates (session management, test presentation, diagnosis, fix planning, routing).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-wizard",
-  "version": "2.8.1",
+  "version": "2.9.1",
   "description": "A lightweight workflow automation and context engineering system for Claude Code, OpenCode, Gemini CLI, Codex, and Copilot CLI.",
   "bin": {
     "pan-wizard": "bin/install.js"

package/pan-wizard-core/bin/lib/commands.cjs

@@ -3,7 +3,7 @@
  */
 const fs = require('fs');
 const path = require('path');
-const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix } = require('./core.cjs');
+const { safeReadFile, loadConfig, isGitIgnored, isGitRepo, execGit, normalizePhaseName, comparePhaseNum, getArchivedPhaseDirs, generateSlugInternal, getMilestoneInfo, resolveModelInternal, detectProvider, resolveTierToModel, estimateCostMultiplier, MODEL_PROFILES, output, error, findPhaseInternal, scanPendingTodos, toPosix } = require('./core.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { PLANNING_DIR, PHASES_DIR, MILESTONES_DIR, QUICK_DIR, STATE_FILE, ROADMAP_FILE, PROJECT_FILE, PATTERNS_FILE, SESSION_HISTORY_FILE, LEARNINGS_FILE, CONTEXT_SUFFIX, UAT_SUFFIX, VERIFICATION_SUFFIX, isPlanFile, isSummaryFile, ARCHIVE_DIR_RE, PHASE_DIR_RE, CONTEXT_WINDOW, WARNING_THRESHOLD, CRITICAL_THRESHOLD, VALID_COMMIT_TYPES, DEFAULT_SENSITIVE_PATTERNS } = require('./constants.cjs');
 const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles } = require('./utils.cjs');
@@ -272,29 +272,50 @@ function cmdHistoryDigest(cwd, raw) {
  * @param {string} cwd - Working directory path
  * @param {string} agentType - Agent type identifier (e.g., "pan-executor", "pan-planner")
  * @param {boolean} raw - If true, output raw model name instead of JSON
+ * @param {string} [metadataJson] - Optional JSON string with task metadata for complexity routing
  * @returns {void}
  */
-function cmdResolveModel(cwd, agentType, raw) {
+function cmdResolveModel(cwd, agentType, raw, metadataJson) {
   if (!agentType) {
     error('agent-type required');
   }
 
+  let taskMetadata = null;
+  if (metadataJson) {
+    try { taskMetadata = JSON.parse(metadataJson); }
+    catch { /* ignore invalid metadata, use static routing */ }
+  }
+
   const config = loadConfig(cwd);
   const profile = config.model_profile || 'balanced';
+  const strategy = config.routing?.strategy || 'static';
 
   const agentModels = MODEL_PROFILES[agentType];
   if (!agentModels) {
-    const result = { model: 'sonnet', profile, unknown_agent: true };
-    output(result, raw, 'sonnet');
+    const model = resolveTierToModel('mid', detectProvider(cwd, config));
+    const result = { model, profile, strategy, unknown_agent: true };
+    output(result, raw, model);
     return;
   }
 
-  const resolved = agentModels[profile] || agentModels['balanced'] || 'sonnet';
-  const model = resolved === 'opus' ? 'inherit' : resolved;
-  const result = { model, profile };
+  const model = resolveModelInternal(cwd, agentType, taskMetadata);
+  const result = { model, profile, strategy };
   output(result, raw, model);
 }
 
+/**
+ * Estimate cost multipliers for all profiles.
+ * @param {string} cwd - Working directory path
+ * @param {boolean} raw - If true, output formatted text instead of JSON
+ * @returns {void}
+ */
+function cmdEstimateCost(cwd, raw) {
+  const estimates = ['quality', 'balanced', 'budget'].map(estimateCostMultiplier);
+  output({ estimates }, raw, estimates.map(e =>
+    `${e.profile}: ~${e.average}x baseline (${e.agentCount} agents)`
+  ).join('\n'));
+}
+
 
 /**
  * Stage and commit planning files to git, respecting commit_docs config and gitignore.
@@ -1416,6 +1437,7 @@ module.exports = {
   cmdVerifyPathExists,
   cmdHistoryDigest,
   cmdResolveModel,
+  cmdEstimateCost,
   cmdCommit,
   cmdSummaryExtract,
   cmdWebsearch,

package/pan-wizard-core/bin/lib/config.cjs

@@ -70,6 +70,15 @@ function buildConfigDefaults(hasBraveSearch, userDefaults) {
       rollback_snapshots: true,
       error_pattern_learning: true,
     },
+    routing: {
+      strategy: 'static',
+      provider: 'auto',
+      cascade_quality_gate: true,
+      complexity_thresholds: {
+        downgrade_max: 2,
+        upgrade_min: 6,
+      },
+    },
   };
   return {
     ...hardcoded,
@@ -78,6 +87,7 @@ function buildConfigDefaults(hasBraveSearch, userDefaults) {
     budget: { ...hardcoded.budget, ...(userDefaults.budget || {}) },
     commit: { ...hardcoded.commit, ...(userDefaults.commit || {}) },
     execution: { ...hardcoded.execution, ...(userDefaults.execution || {}) },
+    routing: { ...hardcoded.routing, ...(userDefaults.routing || {}) },
   };
 }
 

package/pan-wizard-core/bin/lib/constants.cjs

@@ -123,7 +123,7 @@ const FOCUS_DIR = 'focus';
 const AUTO_RUN_FILE = 'auto-run.json';
 
 /** Focus auto-runner categories */
-const FOCUS_CATEGORIES = ['cleanup', 'tests', 'stability', 'features', 'docs', 'optimize'];
+const FOCUS_CATEGORIES = ['cleanup', 'tests', 'stability', 'features', 'docs', 'optimize', 'prompts'];
 
 /** Category → priority index range (indices into PRIORITY_LEVELS) */
 const CATEGORY_PRIORITY_RANGE = {
@@ -133,6 +133,7 @@ const CATEGORY_PRIORITY_RANGE = {
   features:  { min: 3, max: 5 },  // P3-P5
   docs:      { min: 5, max: 6 },  // P5-P6
   optimize:  { min: 1, max: 4 },  // P1-P4
+  prompts:   { min: 0, max: 6 },  // P0-P6 (all priorities — prompt order is authoritative)
 };
 
 /** Category → default mode + budget */
@@ -143,6 +144,7 @@ const CATEGORY_DEFAULTS = {
   features:  { mode: 'features', budget: 50 },
   docs:      { mode: 'balanced', budget: 30 },
   optimize:  { mode: 'balanced', budget: 50 },
+  prompts:   { mode: 'balanced', budget: 100 },
 };
 
 /** Doc files to scan for staleness (focus sync) */