pan-wizard 3.5.2 → 3.8.0

package/pan-wizard-core/references/schemas/pan-command.schema.yml

@@ -0,0 +1,39 @@
+# Schema describing PAN's commands/pan/*.md frontmatter shape.
+# Used by the dogfood gate (REQ-06) and shipped to PAN as the canonical
+# command-frontmatter schema (consumed by `pan-tools doc-lint`).
+#
+# Schema evolved across two dogfood passes:
+#   - Pass 1: pattern accommodates "pan:" prefix; argument-hint added
+#   - Pass 2 (v3.7.1): added agent, type, argument-instructions per real usage
+#
+# Per P-202 (universal): schemas should be inferred from real files, not authored
+# from imagination. Every field below was added because a real PAN command file
+# uses it.
+
+fields:
+  name:
+    required: true
+    type: string
+    pattern: ^(pan:)?[a-z][a-z0-9-]*$
+  group:
+    required: false
+    type: string
+  description:
+    required: false
+    type: string
+  allowed-tools:
+    required: false
+    type: array
+    items: string
+  argument-hint:
+    required: false
+    type: string
+  argument-instructions:
+    required: false
+    type: string
+  agent:
+    required: false
+    type: string
+  type:
+    required: false
+    type: string

package/pan-wizard-core/references/verification-patterns.md

@@ -558,6 +558,37 @@ Run these checks against each must-have artifact. Aggregate results into VERIFIC
 
 <human_verification_triggers>
 
+## Verifiable Signals Beat Prose Judgment (P-RES-006)
+
+**Principle:** When evaluating a plan, a phase, or a code change, prefer signals you can MECHANICALLY check over signals that require LLM-as-judge prose review. Naive self-critique without grounded rewards is largely ineffective and can hurt via overthinking (S2R, ACL 2025; broader RLVR thread). The structural value of PAN's verification roles is in the **fresh-context restart** and **file-mediated re-reading**, not in the prose verdict itself.
+
+**For every verification dimension, ask first: is there a verifiable check that produces this signal mechanically?**
+
+| Verification need | Prose-judge approach (weak) | Verifiable approach (strong) |
+|---|---|---|
+| "Does the code work?" | Read the code, decide | `npm test` exit 0; `npm run build` exit 0 |
+| "Does it follow conventions?" | Read it, judge style | `npm run lint`; `prettier --check`; AST scan against codebase/CONVENTIONS.md |
+| "Are there security issues?" | Read for OWASP patterns | `npm audit`; `semgrep`; regex anti-pattern scan; explicit threat-model checklist with bool answers |
+| "Are types coherent?" | Read for likely mismatches | `tsc --noEmit`; type-graph verify |
+| "Does the plan cover the goal?" | Judge whether the plan is "good" | Mechanical check: every must_have appears as a `<task>` `<verify>`; every requirement ID appears in `requirements:` frontmatter (this is what Dimensions 1, 6 already do) |
+| "Did the executor diverge?" | Re-read the code, decide | `git diff` against the plan's `<files>` list; flag files touched outside the plan; flag missing files from the plan |
+
+**When prose review IS the right tool:**
+- The signal is genuinely subjective (UX feel, error-message helpfulness)
+- The check would require so much custom code that the cost dwarfs an agent invocation
+- The output is for a human reader, not a downstream agent
+
+**When prose review is theatre and should be cut:**
+- A verifiable check exists but wasn't wired in (cheap to fix)
+- The reviewer is judging another reviewer's prose (meta-judgment compounds noise)
+- The verdict is a binary that boils down to "does X exist in Y" (a grep, not a chat)
+
+**Implication for the agents:** `pan-plan-checker`, `pan-verifier`, `pan-reviewer`, `pan-meta-reviewer`, `pan-hardener` should each periodically audit their own prose-vs-mechanical check ratio. If a dimension is 100% prose, ask whether the role earns its compute or whether the structural reset (fresh context, forced re-reading of plan/code) is doing the real work.
+
+**Source:** `pan-wizard-core/learnings/internal/external-research.md` P-RES-006 (S2R / RLVR, ACL 2025).
+
+---
+
 ## When to Require Human Verification
 
 Some things can't be verified programmatically. Flag these for human testing:

package/pan-wizard-core/templates/config.json

@@ -6,7 +6,8 @@
     "plan_check": true,
     "verifier": true,
     "auto_advance": false,
-    "nyquist_validation": false
+    "nyquist_validation": false,
+    "phase_record_compact": false
   },
   "planning": {
     "commit_docs": true,

package/pan-wizard-core/templates/idea.md

@@ -0,0 +1,52 @@
+---
+title: "<one-line idea title>"
+created: "<ISO-8601>"
+created_by: "<user>"
+runtime_preference: claude
+budget: 80
+priority: medium
+---
+
+# Idea: <title>
+
+## Problem
+
+What user pain does this address? Be concrete — what's broken, slow, or missing today?
+
+## Success Criteria
+
+What does "this works" look like? List 3-5 measurable outcomes:
+
+- SC-1: [observable, testable]
+- SC-2: ...
+- SC-3: ...
+
+## Scope
+
+| In Scope | Out of Scope |
+|----------|--------------|
+| ... | ... |
+
+## Constraints
+
+- **Tech stack:** <language, framework>
+- **Dependencies:** <required libs, services>
+- **Deadlines:** <if any>
+- **Runtime support:** <which AI coding tools must work>
+- **Performance:** <if any non-functional requirements>
+
+## Reference Material (optional)
+
+- @path/to/related-doc.md
+- https://link/to/inspiration
+
+## Notes (optional)
+
+Free-form context the external agent should know — design preferences, prior
+art to mimic, things explicitly to avoid.
+
+---
+
+> **How this is consumed:** This file is read by `/pan:experiment new <slug>`
+> and copied to `<experiment-folder>/.planning/idea.md`. The experiment's
+> external AI session reads it as the Phase 0 answer when scaffolding.

package/pan-wizard-core/templates/summary-complex.md

@@ -45,14 +45,23 @@ completed: YYYY-MM-DD
 - `path/to/file.ts` - What it does
 - `path/to/another.ts` - What it does
 
-## Decisions Made
-[Key decisions with brief rationale]
+## Implementation Decisions
+<!-- Schema: @~/.claude/pan-wizard-core/references/handoff-decisions.md -->
 
-## Deviations from Plan (Auto-fixed)
-[Detailed auto-fix records per PAN deviation rules]
+### Taken (within plan's discretion)
+- DT-1: Chose [option] for O-N. Reason: [rationale].
+
+### Deviations (from plan; must explain)
+- DV-1: Plan said [X]; I did [Y]. Reason: [rationale]. Verification: [how I confirmed Y is acceptable].
+
+### Open questions for verifier
+- Q-1: [question]. Why it matters: [stake].
+
+<!-- If none: "No deviations or open questions — implementation followed plan exactly." -->
 
 ## Issues Encountered
-[Problems during planned work and resolutions]
+[Problems during planned work and resolutions — distinct from Deviations above:
+ Issues = bugs/blockers fixed; Deviations = intentional departures from plan]
 
 ## Next Phase Readiness
 [What's ready for next phase]

package/pan-wizard-core/templates/summary-minimal.md

@@ -37,5 +37,11 @@ completed: YYYY-MM-DD
 ## Files Created/Modified
 - `path/to/file.ts` - What it does
 
+## Implementation Decisions
+<!-- Compact form for minimal summaries. Schema: @~/.claude/pan-wizard-core/references/handoff-decisions.md -->
+
+[One line each, or this single line if none:
+ "No deviations or open questions — implementation followed plan exactly."]
+
 ## Next Phase Readiness
 [Ready for next phase]

package/pan-wizard-core/templates/summary-standard.md

@@ -41,9 +41,20 @@ completed: YYYY-MM-DD
 - `path/to/file.ts` - What it does
 - `path/to/another.ts` - What it does
 
-## Decisions & Deviations
-[Key decisions or "None - followed plan as specified"]
-[Minor deviations if any, or "None"]
+## Implementation Decisions
+<!-- Schema: @~/.claude/pan-wizard-core/references/handoff-decisions.md -->
+
+### Taken (within plan's discretion)
+- DT-1: Chose [option] for O-N. Reason: [rationale].
+
+### Deviations (from plan; must explain)
+- DV-1: Plan said [X]; I did [Y]. Reason: [rationale]. Verification: [how I confirmed Y is acceptable].
+
+### Open questions for verifier
+- Q-1: [question]. Why it matters: [stake].
+
+<!-- If none: replace ALL three buckets with:
+     "No deviations or open questions — implementation followed plan exactly." -->
 
 ## Next Phase Readiness
 [What's ready for next phase]

package/pan-wizard-core/workflows/discuss-phase.md

@@ -126,7 +126,114 @@ Use /pan:progress to see available phases.
 ```
 Exit workflow.
 
-**If `phase_found` is true:** Continue to check_existing.
+**If `phase_found` is true:** Continue to auto_mode_bypass.
+</step>
+
+<step name="auto_mode_bypass">
+**P-1803 fix (v3.7.8):** When `--auto` is set or `workflow.auto_advance: true`, **skip the entire question-driven discussion** and synthesize a minimal `context.md` directly from upstream artifacts. The 6 unguarded `AskUserQuestion` calls in this workflow (lines ~140, 156, 208, 261, 264, 278) all stall headless `claude -p` sessions immediately. Surfaced by the wookie autonomous build (v3.7.7): retry attempts via `/pan:discuss-phase 3 --auto` exited in 75s with $0.42 cost and zero commits before plan-phase auto-mode was patched to bypass discuss-phase entirely. This step makes discuss-phase itself auto-mode-safe, so it can be re-introduced into the auto pipeline cleanly.
+
+Detect auto mode:
+
+```bash
+HAS_AUTO_FLAG=$(echo "$ARGUMENTS" | grep -c -- '--auto' || true)
+AUTO_CFG=$(node ~/.claude/pan-wizard-core/bin/pan-tools.cjs config-get workflow.auto_advance 2>/dev/null || echo "false")
+```
+
+**If `HAS_AUTO_FLAG` > 0 OR `AUTO_CFG` is `true`:**
+
+Skip the interactive flow. Generate `context.md` from the roadmap goal + idea.md (if present) + project.md + requirements.md, then jump to `write_context` with the synthesized content. Specifically:
+
+1. Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PAN ► AUTO-MODE: synthesizing context from upstream artifacts
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+2. Read inputs:
+```bash
+ROADMAP_GOAL=$(node ~/.claude/pan-wizard-core/bin/pan-tools.cjs roadmap get-phase "${PHASE}" --raw | sed -n '/^Goal:/,/^$/p')
+IDEA_PATH=".planning/idea.md"
+PROJECT_PATH=".planning/project.md"
+REQ_PATH=".planning/requirements.md"
+```
+
+3. Build a synthesized context.md (skip `analyze_phase`, `present_gray_areas`, `discuss_areas`, `summarize_decisions`, and the Plans-exist branch — go directly to a minimal but valid context.md):
+
+```markdown
+# Phase ${PHASE}: ${PHASE_NAME} - Context
+
+**Gathered:** [today]
+**Status:** Ready for planning
+**Source:** Auto-mode synthesis (P-1803, v3.7.8) — derived from idea.md + project.md + requirements.md without user dialogue
+
+<domain>
+## Phase Boundary
+
+[Goal extracted verbatim from roadmap.md]
+
+</domain>
+
+<decisions>
+## Implementation Decisions
+
+### From idea.md
+[For each item in idea.md "Constraints" / "Scope" / "Notes for the planner" sections that mentions Phase ${PHASE} or its domain keywords (e.g., "image pipeline" for Phase 3) — extract as a locked decision, prefixed with the domain name]
+
+### From requirements.md
+[For each requirement marked Active that maps to Phase ${PHASE} via `requirements.md`'s phase column — list as a locked decision]
+
+### Claude's Discretion
+- Implementation patterns within the constraints above (the planner decides specific libraries / file layouts / function shapes)
+- Test names, fixture data, mock strategy
+- Internal variable / function naming
+- Comment density and inline doc style
+
+</decisions>
+
+<specifics>
+## Specific References
+
+[Any concrete examples, library names, or file paths mentioned in idea.md "Reference material" or "Notes" sections that apply to this phase]
+
+</specifics>
+
+<deferred>
+## Deferred Ideas
+
+None — auto-mode synthesis honors the original idea.md scope.
+
+</deferred>
+
+---
+
+*Phase: ${PADDED_PHASE}-${PHASE_SLUG}*
+*Context auto-synthesized: [today] via discuss-phase P-1803 bypass — no user dialogue*
+```
+
+Write the file:
+```bash
+mkdir -p "${phase_dir}"
+# Use Write tool (NOT heredoc) to create ${phase_dir}/${PADDED_PHASE}-context.md
+```
+
+4. Commit if `commit_docs` is true:
+```bash
+node ~/.claude/pan-wizard-core/bin/pan-tools.cjs commit "docs(${PADDED_PHASE}): auto-synthesize phase context (P-1803)" --files "${phase_dir}/${PADDED_PHASE}-context.md"
+```
+
+5. Log a trace event:
+```bash
+node ~/.claude/pan-wizard-core/bin/pan-tools.cjs optimize trace log \
+  --type decision --category context-auto-synthesized \
+  --description "Phase ${PHASE} P-1803 bypass: context.md auto-synthesized in auto-mode without user dialogue" \
+  --agent orchestrator --impact minor 2>/dev/null || true
+```
+
+6. **Skip ahead to `auto_advance` step** (existing step that spawns plan-phase via Task). Do NOT pass through `check_existing`, `analyze_phase`, `present_gray_areas`, `discuss_areas`, `summarize_decisions` — those all contain unguarded AskUserQuestion calls.
+
+**If neither `HAS_AUTO_FLAG` > 0 nor `AUTO_CFG` is true:** Continue to `check_existing` (interactive flow with full question-driven discussion).
+
 </step>
 
 <step name="check_existing">

package/pan-wizard-core/workflows/exec-phase.md

@@ -8,8 +8,23 @@ Orchestrator coordinates, not executes. Each subagent loads the full execute-pla
 
 <required_reading>
 Read state.md before any operation to load project context.
+
+@~/.claude/pan-wizard-core/references/guardrails.md
+
+> **Also see:** `~/.claude/pan-wizard-core/learnings/universal/` — AI-derived patterns from prior experiments. **Don't skim the whole folder.** Run `pan-tools learn topics-for --agent executor --token-budget 5000 --raw` to load only the topics tagged relevant for execution at the configured budget. Per P-RES-002 (distractor-density research), reading every topic degrades reasoning even at modest token counts. Files appear here over time as `pan-tools learn promote` adds findings.
 </required_reading>
 
+## Re-Read Checkpoints
+
+Context compaction may have dropped earlier sections. Re-read the relevant section *before* you begin each step — not after you hit a problem.
+
+| Before this step | Re-read | Why |
+|------------------|---------|-----|
+| Spawning a subagent | This workflow's `<step name="execute">` block | Wave/segment routing is easy to misremember after compaction |
+| Writing code in a plan | `references/tdd.md` + plan file | Conventions and the plan's tasks drift across long sessions |
+| Committing | `references/guardrails.md` | Pre-commit shortcuts (silent model swaps, scope creep) are tempting under pressure |
+| Marking phase complete | `workflows/verify-phase.md` | Completion criteria are easy to misremember |
+
 <process>
 
 <step name="initialize" priority="first">
@@ -497,7 +512,28 @@ Create verification.md.",
 
 Read status:
 ```bash
-grep "^status:" "$PHASE_DIR"/*-verification.md | cut -d: -f2 | tr -d ' '
+VERIF_STATUS=$(grep "^status:" "$PHASE_DIR"/*-verification.md | cut -d: -f2 | tr -d ' ')
+```
+
+**P-1806 fix (v3.7.8):** the trace event for verify-phase outcome is logged HERE (in exec-phase.md after the verifier returns) rather than only at the end of verify-phase.md. When verification runs inline (orchestrator-as-verifier in auto mode, no separate Task spawn), the trace.log block at the bottom of verify-phase.md never executes — the orchestrator just writes verification.md and continues. By logging here, the event fires regardless of the verification path taken. Surfaced by the wookie autonomous build (v3.7.5–v3.7.7): all 5 phases used inline verification, no `verification_passed` events appeared in the trace despite v3.7.5 adding the trace block to verify-phase.md.
+
+```bash
+if [ "$VERIF_STATUS" = "passed" ]; then
+  node ~/.claude/pan-wizard-core/bin/pan-tools.cjs optimize trace log \
+    --type decision --category verification_passed \
+    --description "Phase ${PHASE_NUMBER} verification passed (logged from exec-phase, P-1806)" \
+    --agent pan-verifier --impact minor 2>/dev/null || true
+elif [ "$VERIF_STATUS" = "gaps_found" ]; then
+  node ~/.claude/pan-wizard-core/bin/pan-tools.cjs optimize trace log \
+    --type error --category verification_gaps \
+    --description "Phase ${PHASE_NUMBER} verification found gaps" \
+    --agent pan-verifier --impact major 2>/dev/null || true
+elif [ "$VERIF_STATUS" = "human_needed" ]; then
+  node ~/.claude/pan-wizard-core/bin/pan-tools.cjs optimize trace log \
+    --type decision --category verification_human_needed \
+    --description "Phase ${PHASE_NUMBER} verification awaiting human review" \
+    --agent pan-verifier --impact minor 2>/dev/null || true
+fi
 ```
 
 | Status | Action |

package/pan-wizard-core/workflows/execute-plan.md

@@ -7,8 +7,22 @@ Read state.md before any operation to load project context.
 Read config.json for planning behavior settings.
 
 @~/.claude/pan-wizard-core/references/git-integration.md
+@~/.claude/pan-wizard-core/references/guardrails.md
+
+> **Also see:** `~/.claude/pan-wizard-core/learnings/universal/` — AI-derived patterns from prior experiments. **Don't skim the whole folder.** Run `pan-tools learn topics-for --agent executor --token-budget 5000 --raw` to load only the topics tagged relevant for execution at the configured budget. Per P-RES-002 (distractor-density research), reading every topic degrades reasoning even at modest token counts.
 </required_reading>
 
+## Re-Read Checkpoints
+
+Context compaction may have dropped earlier sections. Re-read the relevant section *before* you begin each step — not after you hit a problem.
+
+| Before this step | Re-read | Why |
+|------------------|---------|-----|
+| Each task in the plan | This workflow's `<deviation_rules>` block | Rule 1-4 boundaries are easy to misremember |
+| Hitting an unexpected error | This workflow's `<authentication_gates>` block | Auth errors are not failures — recognize the pattern |
+| Committing | `references/guardrails.md` + `references/git-planning-commit.md` | Commit conventions and Code Preservation apply to every commit |
+| Writing the summary | This workflow's `<deviation_documentation>` block | Summary shape is checked by verify-phase |
+
 <process>
 
 <step name="init_context" priority="first">

package/pan-wizard-core/workflows/health.md

@@ -37,6 +37,29 @@ Parse JSON output:
 - `repairs_performed[]`: Actions taken if --repair was used
 </step>
 
+<step name="run_doc_lint">
+**Run frontmatter doc-lint (v3.7.1+):**
+
+Lints the project's markdown files (commands, agents, workflows) against
+the PAN command schema. Catches frontmatter drift at author time —
+missing `name`, wrong types, malformed YAML — before they cause runtime
+issues during install or dispatch.
+
+```bash
+# Lint commands/pan/ if it exists in the host project (PAN-source dogfood)
+if [ -d commands/pan ]; then
+  node ~/.claude/pan-wizard-core/bin/pan-tools.cjs doc-lint commands/pan --raw 2>&1
+fi
+```
+
+A clean run prints `Linted N file(s): 0 error(s), 0 warning(s)`. Any errors
+get folded into the health report's `warnings[]` section as
+`code: doc-lint-frontmatter` entries — they're non-blocking but actionable.
+
+Skip silently if `commands/pan/` doesn't exist (most user projects).
+Pattern source: P-201 + P-202 + P-301 (whooo experiment, ADR-0026).
+</step>
+
 <step name="format_output">
 **Format and display results:**
 

package/pan-wizard-core/workflows/new-project.md

@@ -4,8 +4,25 @@ Initialize a new project through unified flow: questioning, research (optional),
 
 <required_reading>
 Read all files referenced by the invoking prompt's execution_context before starting.
+
+@~/.claude/pan-wizard-core/references/guardrails.md
 </required_reading>
 
+## Phase 0 — Clarify (MANDATORY, do not skip)
+
+Before scaffolding or coding anything, confirm with the user:
+
+1. **What problem will this solve?** — Core purpose, not the implementation
+2. **What does success look like?** — Concrete, measurable outcomes
+3. **What's in scope vs out of scope?** — Boundary definition
+4. **Constraints?** — Tech stack, dependencies, deadlines, runtime support requirements
+
+**Do NOT proceed** until the user has answered. Do not assume, research, or fill in blanks yourself. The user's intent drives everything — skipping this step leads to wasted scaffolding and mis-aligned implementation.
+
+Save answers to `.planning/requirements.md` (or update if exists). Confirm with the user before scaffolding.
+
+> **Auto mode exception:** If `--auto` is set with a provided idea document (see `<auto_mode>` below), the document IS the Phase 0 answer. Read it carefully and extract problem / success / scope / constraints from its contents.
+
 <auto_mode>
 ## Auto Mode Detection
 
@@ -81,89 +98,38 @@ Exit command.
 
 ## 2a. Auto Mode Config (auto mode only)
 
-**If auto mode:** Collect config settings upfront before processing the idea document.
+**If auto mode:** Apply defaults silently — do NOT call AskUserQuestion. The whole point of `--auto` is non-interactive execution; asking questions here blocks autonomous runs (P-1301 fix, v3.7.2).
 
-YOLO mode is implicit (auto = YOLO). Ask remaining config questions:
+**Auto-mode defaults (applied without asking):**
 
-**Round 1 — Core settings (3 questions, no Mode question):**
+| Setting | Default | Override via |
+|---------|---------|--------------|
+| Depth | `quick` (3-5 phases, 1-3 plans each) | idea.md frontmatter `planning_depth: standard\|comprehensive` |
+| Execution | `parallel` | idea.md frontmatter `parallelization: false` to switch to sequential |
+| Git Tracking | `yes` (commit_planning_docs: true) | idea.md frontmatter `commit_planning_docs: false` |
+| Research | `yes` (each phase researched before planning) | idea.md frontmatter `research_enabled: false` |
+| Plan Check | `yes` (verify plans before exec) | idea.md frontmatter `plan_checker_enabled: false` |
+| Verifier | `yes` (verify work after each phase) | idea.md frontmatter `verifier_enabled: false` |
+| AI Models | `balanced` profile | idea.md frontmatter `model_profile: quality\|budget` |
 
-```
-AskUserQuestion([
-  {
-    header: "Depth",
-    question: "How thorough should planning be?",
-    multiSelect: false,
-    options: [
-      { label: "Quick (Recommended)", description: "Ship fast (3-5 phases, 1-3 plans each)" },
-      { label: "Standard", description: "Balanced scope and speed (5-8 phases, 3-5 plans each)" },
-      { label: "Comprehensive", description: "Thorough coverage (8-12 phases, 5-10 plans each)" }
-    ]
-  },
-  {
-    header: "Execution",
-    question: "Run plans in parallel?",
-    multiSelect: false,
-    options: [
-      { label: "Parallel (Recommended)", description: "Independent plans run simultaneously" },
-      { label: "Sequential", description: "One plan at a time" }
-    ]
-  },
-  {
-    header: "Git Tracking",
-    question: "Commit planning docs to git?",
-    multiSelect: false,
-    options: [
-      { label: "Yes (Recommended)", description: "Planning docs tracked in version control" },
-      { label: "No", description: "Keep .planning/ local-only (add to .gitignore)" }
-    ]
-  }
-])
-```
-
-**Round 2 — Workflow agents (same as Step 5):**
+**To use a non-default value in auto mode, embed it in the idea.md frontmatter:**
 
-```
-AskUserQuestion([
-  {
-    header: "Research",
-    question: "Research before planning each phase? (adds tokens/time)",
-    multiSelect: false,
-    options: [
-      { label: "Yes (Recommended)", description: "Investigate domain, find patterns, surface gotchas" },
-      { label: "No", description: "Plan directly from requirements" }
-    ]
-  },
-  {
-    header: "Plan Check",
-    question: "Verify plans will achieve their goals? (adds tokens/time)",
-    multiSelect: false,
-    options: [
-      { label: "Yes (Recommended)", description: "Catch gaps before execution starts" },
-      { label: "No", description: "Execute plans without verification" }
-    ]
-  },
-  {
-    header: "Verifier",
-    question: "Verify work satisfies requirements after each phase? (adds tokens/time)",
-    multiSelect: false,
-    options: [
-      { label: "Yes (Recommended)", description: "Confirm deliverables match phase goals" },
-      { label: "No", description: "Trust execution, skip verification" }
-    ]
-  },
-  {
-    header: "AI Models",
-    question: "Which AI models for planning agents?",
-    multiSelect: false,
-    options: [
-      { label: "Balanced (Recommended)", description: "Sonnet for most agents — good quality/cost ratio" },
-      { label: "Quality", description: "Opus for research/roadmap — higher cost, deeper analysis" },
-      { label: "Budget", description: "Haiku where possible — fastest, lowest cost" }
-    ]
-  }
-])
+```yaml
+---
+title: "..."
+runtime_preference: claude
+budget: 30
+priority: medium
+# Optional auto-mode overrides:
+planning_depth: standard
+parallelization: false
+research_enabled: false
+model_profile: quality
+---
 ```
 
+**Read the idea.md frontmatter once, apply the defaults, log them, proceed.** No AskUserQuestion in this block. If frontmatter is missing/silent on a setting, use the table default.
+
 Create `.planning/config.json` with mode set to "yolo":
 
 ```json
@@ -1032,14 +998,20 @@ If the command succeeds (project.md exists and project types detected):
 
 Parse JSON for `project_types` and `recommendations` arrays.
 
-**If auto mode:** Auto-select the top 2 recommended standards and commit:
+**If auto mode (P-1601 v3.7.5):** Auto-select ONLY `priority: "high"` recommendations. These are recommendations from explicitly-detected non-general project types (e.g., a recognized `web` or `ai` project). For `general` fallback projects with no explicit type signal, **skip auto-selection entirely** — leave `standards.md` absent rather than impose unrelated standards.
 
 ```bash
-node ./.claude/pan-wizard-core/bin/pan-tools.cjs standards select [first_id]
-node ./.claude/pan-wizard-core/bin/pan-tools.cjs standards select [second_id]
-node ./.claude/pan-wizard-core/bin/pan-tools.cjs commit "docs: add recommended standards" --files .planning/standards.md
+HIGH_IDS=$(echo "$RECOMMEND" | jq -r '.recommendations[] | select(.priority=="high") | .id')
+if [ -n "$HIGH_IDS" ]; then
+  for id in $HIGH_IDS; do
+    node ./.claude/pan-wizard-core/bin/pan-tools.cjs standards select "$id"
+  done
+  node ./.claude/pan-wizard-core/bin/pan-tools.cjs commit "docs: add recommended standards" --files .planning/standards.md
+fi
 ```
 
+Skipping auto-select when the project is `general` keeps `.planning/` minimal for trivial CLIs / scripts and avoids inflating agent context with irrelevant compliance checklists.
+
 **If interactive mode:**
 
 Present recommendations:
@@ -1080,6 +1052,18 @@ Run /pan:health --standards to check compliance anytime.
 
 **If command fails** (no project.md or no recommendations): Skip silently — standards are optional.
 
+## 8.9. Safety-Net Commit (P-EXP-001 fix)
+
+**MANDATORY in auto mode, optional in interactive.** Defensive sweep — if any prior commit step was skipped (auto mode hit context budget early, interactive user dismissed a prompt, etc.), fold any uncommitted `.planning/` artifacts into a single bundle commit so the next workflow run starts from a clean tree.
+
+```bash
+if [ "$(git status --porcelain .planning/ 2>/dev/null)" ]; then
+  node ./.claude/pan-wizard-core/bin/pan-tools.cjs commit "docs: bundle remaining .planning artifacts (safety-net)" --files .planning/
+fi
+```
+
+**Why:** the `whoocache` experiment (2026-05-02) finished new-project with all artifacts on disk (`project.md`, `requirements.md`, `roadmap.md`, src code) but ZERO commits — the autonomous loop reached natural completion before any per-stage `pan-tools commit` invocation. This safety-net catches that pattern.
+
 ## 9. Done
 
 Present completion summary: