maxsimcli 3.11.0 → 4.0.0

package/dist/assets/templates/workflows/execute-phase.md

@@ -36,20 +36,8 @@ Parse JSON for: `executor_model`, `verifier_model`, `commit_docs`, `parallelizat
 When `parallelization` is false, plans within a wave execute sequentially.
 </step>
 
-<step name="launch_dashboard">
-Launch the live project dashboard (if not already running):
-
-```bash
-node ~/.claude/maxsim/bin/maxsim-tools.cjs dashboard 2>/dev/null || true
-```
-
-This is idempotent: if the dashboard is already running, it prints the URL. If not, it spawns a detached subprocess that survives the execute-phase session.
-
-The dashboard provides a real-time visual companion showing phase progress, plan tasks, and blockers as execution proceeds.
-
-**Best-effort:** If the dashboard fails to start (e.g., not installed, build missing), execution continues without it. Do NOT gate phase execution on dashboard availability.
-
-**Dashboard MCP probe:** After the dashboard launch attempt, probe for MCP availability (see @dashboard-bridge). If `DASHBOARD_ACTIVE`, emit:
+<step name="probe_dashboard">
+Probe for MCP dashboard availability (see @dashboard-bridge). If `DASHBOARD_ACTIVE`, emit:
 ```
 mcp__maxsim-dashboard__submit_lifecycle_event(
   event_type: "phase-started",
@@ -57,6 +45,8 @@ mcp__maxsim-dashboard__submit_lifecycle_event(
   phase_number: PHASE_NUMBER
 )
 ```
+
+**Note:** The dashboard is NOT auto-launched. Users start it explicitly via `maxsim dashboard`. This step only checks if a running dashboard is reachable via MCP.
 </step>
 
 <step name="handle_branching">
@@ -162,7 +152,7 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
        - .planning/STATE.md (State)
        - .planning/config.json (Config, if exists)
        - ./CLAUDE.md (Project instructions, if exists — follow project-specific guidelines and coding conventions)
-       - .agents/skills/ (Project skills, if exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
+       - .skills/ (Project skills, if exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
        </files_to_read>
 
        <success_criteria>
@@ -178,15 +168,18 @@ Execute each wave in sequence. Within a wave: parallel if `PARALLELIZATION=true`
 
 3. **Wait for all agents in wave to complete.**
 
-4. **Report completion — spot-check claims first:**
+4. **Report completion — spot-check claims and review cycle:**
 
    For each SUMMARY.md:
    - Verify first 2 files from `key-files.created` exist on disk
    - Check `git log --oneline --all --grep="{phase}-{plan}"` returns ≥1 commit
    - Check for `## Self-Check: FAILED` marker
+   - **Check for `## Review Cycle` section** — verify all review stages show PASS/APPROVED/CLEAN/FIXED (not BLOCKED or FAIL)
 
    If ANY spot-check fails: report which plan failed, route to failure handler — ask "Retry plan?" or "Continue with remaining waves?"
 
+   If review cycle is missing or has unresolved issues: flag the plan as **review-incomplete** — ask "Run review cycle for this plan?" or "Continue (review will block phase completion)?"
+
    If pass — **emit plan-complete lifecycle event** (if `DASHBOARD_ACTIVE`):
    ```
    mcp__maxsim-dashboard__submit_lifecycle_event(
@@ -285,9 +278,26 @@ After all waves:
 1. **03-01**: [one-liner from SUMMARY.md]
 2. **03-02**: [one-liner from SUMMARY.md]
 
+### Review Cycle Summary
+| Plan | Spec Review | Code Review | Simplify | Final Review |
+|------|-------------|-------------|----------|--------------|
+| 03-01 | PASS | APPROVED | CLEAN | — |
+| 03-02 | PASS | APPROVED | FIXED | APPROVED |
+
+[Aggregate review findings from each plan's SUMMARY.md `## Review Cycle` section.
+If any plan has no Review Cycle section: mark as "NOT RUN" and flag for attention.
+If any plan has unresolved BLOCKED/FAIL status: list the blocking issues below.]
+
+### Unresolved Review Issues
+[List any plans with BLOCKED or FAIL review stages. These MUST be resolved before phase completion.]
+
 ### Issues Encountered
 [Aggregate from SUMMARYs, or "None"]
 ```
+
+**Phase completion gate:** If any plan has unresolved review issues (BLOCKED or FAIL in any review stage), the phase CANNOT proceed to `verify_phase_goal`. Present unresolved issues and offer:
+- "Fix review issues now" — re-run the review cycle for affected plans
+- "Override and continue" — mark as acknowledged, proceed (adds warning to VERIFICATION.md)
 </step>
 
 <step name="close_parent_artifacts">

package/dist/assets/templates/workflows/execute-plan.md

@@ -343,6 +343,172 @@ Include: duration, start/end times, task count, file count.
 Next: more plans → "Ready for {next-plan}" | last → "Phase complete, ready for transition".
 </step>
 
+<step name="review_cycle">
+## Execute-Review-Simplify-Review Cycle
+
+After implementation is complete and SUMMARY.md is created, run the full review cycle before proceeding. All four stages must pass before the plan is considered done.
+
+**Stage 1: Spec Review** — Verify implementation matches plan spec.
+
+```
+Task(
+  subagent_type="maxsim-spec-reviewer",
+  prompt="
+    <objective>
+    Review plan {phase}-{plan} for spec compliance.
+    </objective>
+
+    <plan_spec>
+    Plan file: {phase_dir}/{phase}-{plan}-PLAN.md
+    Summary file: {phase_dir}/{phase}-{plan}-SUMMARY.md
+    </plan_spec>
+
+    <task_specs>
+    {For each task in the plan: task number, name, done criteria, files modified}
+    </task_specs>
+
+    <files_modified>
+    {List all files created/modified during execution from SUMMARY.md key-files}
+    </files_modified>
+
+    <instructions>
+    1. Read the plan file and extract every task requirement
+    2. For each requirement, verify the implementation exists and matches the spec
+    3. Check that nothing was added beyond scope
+    4. Report: PASS (all requirements met) or FAIL (list unmet requirements)
+    </instructions>
+  "
+)
+```
+
+**If spec review FAILS:** Fix unmet requirements, re-run verification, update SUMMARY.md, then re-run spec review. Do not proceed until PASS.
+
+**Stage 2: Code Review** — Check code quality, security, error handling.
+
+```
+Task(
+  subagent_type="maxsim-code-reviewer",
+  prompt="
+    <objective>
+    Review plan {phase}-{plan} code quality. Spec compliance already verified.
+    </objective>
+
+    <files_modified>
+    {List all files created/modified during execution from SUMMARY.md key-files}
+    </files_modified>
+
+    <instructions>
+    1. Read CLAUDE.md for project conventions
+    2. Review every modified file for: correctness, conventions, error handling, security, maintainability
+    3. Categorize findings: BLOCKER (must fix), HIGH (should fix), MEDIUM (file for follow-up)
+    4. Report: APPROVED (no blockers/high) or BLOCKED (list blocking issues)
+    </instructions>
+  "
+)
+```
+
+**If code review is BLOCKED:** Fix all blocker and high-severity issues. Re-run code review. Do not proceed until APPROVED.
+
+**Stage 3: Simplify** — Spawn 3 parallel reviewers to catch reuse opportunities, quality issues, and inefficiencies.
+
+```
+Task(
+  subagent_type="maxsim-executor",
+  prompt="
+    <objective>
+    Run simplification review on plan {phase}-{plan} with 3 parallel reviewers.
+    </objective>
+
+    <instructions>
+    Spawn 3 parallel review agents for the files modified in this plan:
+
+    Agent 1 — Code Reuse:
+    - Find duplicated logic across the codebase
+    - Identify copy-paste from other files that should be extracted
+    - Suggest shared helpers for patterns appearing 3+ times
+    - Check if existing utilities could replace new code
+
+    Agent 2 — Code Quality:
+    - Check naming consistency with codebase conventions
+    - Verify error handling covers all external calls
+    - Look for dead code: unused imports, unreachable branches, commented-out code
+    - Check for unnecessary abstractions or premature generalizations
+
+    Agent 3 — Efficiency:
+    - Find O(n^2) operations where O(n) is straightforward
+    - Identify repeated computations that could be cached or hoisted
+    - Check for unnecessary allocations in hot paths
+    - Look for redundant data transformations
+
+    After all 3 agents report:
+    1. Consolidate findings into a single list
+    2. Apply fixes for all actionable items (skip speculative optimizations)
+    3. Run tests to confirm fixes do not break anything
+    4. Report: CLEAN (no issues found), FIXED (issues found and resolved), or BLOCKED (issues found but cannot fix without architectural change)
+    </instructions>
+
+    <files_to_review>
+    {List all files created/modified during execution from SUMMARY.md key-files}
+    </files_to_review>
+  "
+)
+```
+
+**If simplify is BLOCKED:** Present architectural issues to user via checkpoint protocol. Do not proceed until resolved.
+
+**Stage 4: Final Review** — If simplify made changes, one more code review pass.
+
+Run this stage ONLY if Stage 3 reported FIXED (i.e., simplify found and applied fixes).
+
+```
+Task(
+  subagent_type="maxsim-code-reviewer",
+  prompt="
+    <objective>
+    Final review pass after simplification changes on plan {phase}-{plan}.
+    Verify simplification fixes did not introduce regressions.
+    </objective>
+
+    <context>
+    Previous code review: APPROVED
+    Simplification: FIXED — changes were applied
+    This is a focused re-review of simplification changes only.
+    </context>
+
+    <files_modified>
+    {List files changed by simplification stage}
+    </files_modified>
+
+    <instructions>
+    1. Review only the changes made during simplification
+    2. Verify no regressions were introduced
+    3. Check that simplification changes follow project conventions
+    4. Report: APPROVED or BLOCKED (list issues)
+    </instructions>
+  "
+)
+```
+
+**If final review is BLOCKED:** Fix issues, re-run final review. Do not proceed until APPROVED.
+
+**Review cycle tracking:** Record review results in SUMMARY.md under a `## Review Cycle` section:
+```markdown
+## Review Cycle
+
+| Stage | Result | Findings |
+|-------|--------|----------|
+| Spec Review | PASS | All requirements met |
+| Code Review | APPROVED | No blocking issues |
+| Simplify | FIXED | Extracted shared helper for X, removed unused import Y |
+| Final Review | APPROVED | Simplification changes verified |
+```
+
+Update the SUMMARY.md commit after the review cycle completes:
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs({phase}-{plan}): add review cycle results" --files {phase_dir}/{phase}-{plan}-SUMMARY.md
+```
+</step>
+
 <step name="update_current_position">
 Update STATE.md using maxsim-tools:
 

package/dist/assets/templates/workflows/init-existing.md

@@ -7,8 +7,13 @@ Output: `.planning/` directory with config.json, PROJECT.md, REQUIREMENTS.md, RO
 <required_reading>
 Read all files referenced by the invoking prompt's execution_context before starting.
 @./references/dashboard-bridge.md
+@./references/thinking-partner.md
 </required_reading>
 
+<tool_mandate>
+**Question routing:** At workflow start, probe for the dashboard (see @dashboard-bridge). If `DASHBOARD_ACTIVE = true`, route ALL `AskUserQuestion` calls through `mcp__maxsim-dashboard__ask_question` using the schema translation rules from @dashboard-bridge. If `DASHBOARD_ACTIVE = false`, use `AskUserQuestion` as normal.
+</tool_mandate>
+
 <auto_mode>
 ## Auto Mode Detection
 
@@ -258,7 +263,7 @@ Print per-agent completion status:
 After all agents complete, also create a file tree overview:
 
 ```bash
-find . -type f | grep -v node_modules | grep -v .git | grep -v .planning | grep -v __pycache__ | grep -v .next | grep -v dist/ | grep -v build/ | head -200 > .planning/codebase/STRUCTURE.md
+git ls-files --others --cached --exclude-standard | grep -v node_modules | grep -v __pycache__ | grep -v .next | grep -v dist/ | grep -v build/ | head -200 > .planning/codebase/STRUCTURE.md
 ```
 
 Then wrap it with a header:
@@ -321,7 +326,7 @@ Store discrepancy notes in a variable for use in Steps 6 and 9.
   "model_profile": "balanced",
   "workflow": {
     "research": true,
-    "plan_check": true,
+    "plan_checker": true,
     "verifier": true
   }
 }
@@ -461,7 +466,7 @@ AskUserQuestion([
   "model_profile": "[quality|balanced|budget]",
   "workflow": {
     "research": [true|false],
-    "plan_check": [true|false],
+    "plan_checker": [true|false],
     "verifier": [true|false]
   }
 }
@@ -525,6 +530,11 @@ Ask user to confirm or correct via AskUserQuestion:
 
 If "Some corrections": ask "What needs correcting?" (freeform), capture corrections, apply to working context.
 
+Apply thinking-partner behaviors when presenting findings:
+- **Surface unstated assumptions** — "The scan assumes X is your primary framework — is that accurate?"
+- **Make consequences visible** — "Your architecture pattern means Y for future phases."
+- **Propose alternatives** — If concerns were found, suggest approaches: "The scan found tech debt in Z. We could address it early or defer — here are the trade-offs."
+
 ## Step 7: Future Direction Questions
 
 **If auto mode:** Skip. Generate generic "continue development" goals. Proceed to Step 9.
@@ -624,6 +634,15 @@ Ask inline (freeform, NOT AskUserQuestion):
 
 Wait for response.
 
+**Thinking-partner follow-up on vision:**
+
+After the user shares their vision, apply thinking-partner behaviors:
+- Challenge vague statements: "You said 'improve performance' — improve which operations, for which users?"
+- Surface assumptions: "That assumes users will migrate from X — is that the plan?"
+- Propose alternatives if the vision seems narrow: "Have you considered approaching it from Y angle instead?"
+
+Use 1-2 follow-up AskUserQuestion prompts to sharpen the vision if needed. Don't over-question — 1-2 rounds max.
+
 ## Step 8: Milestone Suggestion
 
 **If auto mode:** Generate a milestone name from the inferred project purpose. Proceed to Step 9.
@@ -987,6 +1006,104 @@ Pre-populate:
 
 Already written in Step 5. If merge mode and config.json existed, it was preserved (unless user chose overwrite).
 
+### 9f: Artefakte Generation
+
+Generate structured artefakte documents from gathered context.
+
+**DECISIONS.md:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/DECISIONS.md
+```
+
+Write content:
+
+```markdown
+# Key Decisions
+
+**Generated:** [date]
+**Source:** Init-existing initialization
+
+| # | Decision | Rationale | Alternatives Considered | Status |
+|---|----------|-----------|------------------------|--------|
+| 1 | [Config choice: mode] | [Why] | [Other options] | Locked |
+| 2 | [Stage assessment] | [Evidence from scan] | [Other stages considered] | Locked |
+| 3 | [Any constraint decisions from Step 7] | [Why] | [Alternatives] | Locked |
+
+---
+*Decisions captured during /maxsim:init-existing initialization*
+```
+
+**ACCEPTANCE-CRITERIA.md:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/ACCEPTANCE-CRITERIA.md
+```
+
+Write content:
+
+```markdown
+# Acceptance Criteria
+
+**Generated:** [date]
+**Source:** Init-existing initialization
+
+## Project-Level Criteria
+
+- [ ] [Observable outcome from user's vision]
+- [ ] [Observable outcome from user's vision]
+- [ ] [Stability guard from production constraints, if applicable]
+
+## Phase-Level Criteria
+
+Populated per-phase during /maxsim:discuss-phase.
+
+---
+*Criteria derived from init-existing initialization*
+```
+
+**NO-GOS.md:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/NO-GOS.md
+```
+
+Write content:
+
+```markdown
+# No-Gos
+
+**Generated:** [date]
+**Source:** Init-existing initialization
+
+## Must Not Break
+
+[From production constraints / GUARD requirements in REQUIREMENTS.md]
+
+- [Critical thing that cannot break] -- [why]
+
+## Anti-Patterns
+
+[From CONCERNS.md and user input]
+
+- [Approach to avoid] -- [why]
+
+## Scope Boundaries
+
+- [What this milestone is NOT trying to achieve]
+
+---
+*No-gos captured during /maxsim:init-existing initialization*
+```
+
+**If auto mode:** Generate artefakte from scan findings with reasonable inferences. Mark uncertain entries with `(inferred)`.
+
+**Commit artefakte:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs: generate initialization artefakte" --files .planning/DECISIONS.md .planning/ACCEPTANCE-CRITERIA.md .planning/NO-GOS.md
+```
+
 ## Step 10: Git Stage and Summary
 
 Stage all changed files:
@@ -1053,6 +1170,9 @@ Print next steps:
 - `.planning/REQUIREMENTS.md`
 - `.planning/ROADMAP.md`
 - `.planning/STATE.md`
+- `.planning/DECISIONS.md`
+- `.planning/ACCEPTANCE-CRITERIA.md`
+- `.planning/NO-GOS.md`
 - `.planning/codebase/STACK.md`
 - `.planning/codebase/ARCHITECTURE.md`
 - `.planning/codebase/CONVENTIONS.md`

package/dist/assets/templates/workflows/new-milestone.md

@@ -11,6 +11,10 @@ Read all files referenced by the invoking prompt's execution_context before star
 
 </required_reading>
 
+<tool_mandate>
+**Question routing:** At workflow start, probe for the dashboard (see @dashboard-bridge). If `DASHBOARD_ACTIVE = true`, route ALL `AskUserQuestion` calls through `mcp__maxsim-dashboard__ask_question` using the schema translation rules from @dashboard-bridge. If `DASHBOARD_ACTIVE = false`, use `AskUserQuestion` as normal.
+</tool_mandate>
+
 <process>
 
 ## 1. Load Context

package/dist/assets/templates/workflows/new-project.md

@@ -5,8 +5,13 @@ 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.
 @./references/dashboard-bridge.md
+@./references/thinking-partner.md
 </required_reading>
 
+<tool_mandate>
+**Question routing:** At workflow start, probe for the dashboard (see @dashboard-bridge). If `DASHBOARD_ACTIVE = true`, route ALL `AskUserQuestion` calls through `mcp__maxsim-dashboard__ask_question` using the schema translation rules from @dashboard-bridge. If `DASHBOARD_ACTIVE = false`, use `AskUserQuestion` as normal.
+</tool_mandate>
+
 <auto_mode>
 ## Auto Mode Detection
 
@@ -176,7 +181,7 @@ Create `.planning/config.json` with mode set to "yolo":
   "model_profile": "quality|balanced|budget",
   "workflow": {
     "research": true|false,
-    "plan_check": true|false,
+    "plan_checker": true|false,
     "verifier": true|false,
     "auto_advance": true
   }
@@ -220,10 +225,18 @@ Ask inline (freeform, NOT AskUserQuestion):
 
 Wait for their response. This gives you the context needed to ask intelligent follow-up questions.
 
-**Follow the thread:**
+**Follow the thread (thinking-partner mode):**
 
 Based on what they said, ask follow-up questions that dig into their response. Use AskUserQuestion with options that probe what they mentioned — interpretations, clarifications, concrete examples.
 
+Apply thinking-partner behaviors from `thinking-partner.md`:
+- **Challenge vague answers** — "Good UX" means what? Push for specifics.
+- **Surface unstated assumptions** — Name assumptions the user didn't realize they were making.
+- **Propose alternatives with trade-offs** — Don't just accept the first approach. Offer 2-3 paths.
+- **Suggest directions** — "Have you considered...?" Frame as possibilities, not mandates.
+- **Make consequences visible** — "If we go with X, that means Y will need to change."
+- **Disagree constructively** — If you see a risk, say so.
+
 Keep following threads. Each answer opens new threads to explore. Ask about:
 - What excited them
 - What problem sparked this
@@ -342,6 +355,101 @@ mkdir -p .planning
 node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs: initialize project" --files .planning/PROJECT.md
 ```
 
+## 4b. Generate Artefakte
+
+After PROJECT.md is committed, generate artefakte documents that capture structured insights from questioning.
+
+**DECISIONS.md** — Key decisions made during questioning with rationale:
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/DECISIONS.md
+```
+
+Write content:
+
+```markdown
+# Key Decisions
+
+**Generated:** [date]
+**Source:** Project initialization questioning
+
+| # | Decision | Rationale | Alternatives Considered | Status |
+|---|----------|-----------|------------------------|--------|
+| 1 | [Choice from questioning] | [Why this was chosen] | [What else was discussed] | Locked |
+| 2 | [Choice from questioning] | [Why this was chosen] | [What else was discussed] | Locked |
+
+---
+*Decisions captured during /maxsim:new-project initialization*
+```
+
+**ACCEPTANCE-CRITERIA.md** — Measurable success criteria derived from user's vision:
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/ACCEPTANCE-CRITERIA.md
+```
+
+Write content:
+
+```markdown
+# Acceptance Criteria
+
+**Generated:** [date]
+**Source:** Project initialization
+
+## Project-Level Criteria
+
+These define what "done" looks like for the entire project:
+
+- [ ] [Observable outcome from user's vision]
+- [ ] [Observable outcome from user's vision]
+- [ ] [Observable outcome from user's vision]
+
+## Phase-Level Criteria
+
+Populated per-phase during /maxsim:discuss-phase.
+
+---
+*Criteria derived from project initialization*
+```
+
+**NO-GOS.md** — Explicit exclusions and anti-patterns:
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-write .planning/NO-GOS.md
+```
+
+Write content:
+
+```markdown
+# No-Gos
+
+**Generated:** [date]
+**Source:** Project initialization
+
+## Excluded Features
+
+- [Feature explicitly excluded] — [why]
+
+## Anti-Patterns
+
+- [Approach to avoid] — [why]
+
+## Scope Boundaries
+
+- [What this project is NOT]
+
+---
+*No-gos captured during /maxsim:new-project initialization*
+```
+
+**Commit artefakte:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs: generate initialization artefakte" --files .planning/DECISIONS.md .planning/ACCEPTANCE-CRITERIA.md .planning/NO-GOS.md
+```
+
+**If auto mode:** Generate artefakte from the provided document with reasonable inferences. Mark uncertain entries with `(inferred)`.
+
 ## 5. Workflow Preferences
 
 **If auto mode:** Skip — config was collected in Step 2a. Proceed to Step 5.5.
@@ -475,7 +583,7 @@ Create `.planning/config.json` with all settings:
   "model_profile": "quality|balanced|budget",
   "workflow": {
     "research": true|false,
-    "plan_check": true|false,
+    "plan_checker": true|false,
     "verifier": true|false
   }
 }

package/dist/assets/templates/workflows/plan-phase.md

@@ -25,7 +25,7 @@ Load all context in one call (paths only to minimize orchestrator context):
 INIT=$(node ~/.claude/maxsim/bin/maxsim-tools.cjs init plan-phase "$PHASE")
 ```
 
-Parse JSON for: `researcher_model`, `planner_model`, `checker_model`, `research_enabled`, `plan_checker_enabled`, `nyquist_validation_enabled`, `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_research`, `has_context`, `has_plans`, `plan_count`, `planning_exists`, `roadmap_exists`, `phase_req_ids`.
+Parse JSON for: `researcher_model`, `planner_model`, `checker_model`, `research_enabled`, `plan_checker_enabled`, `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_research`, `has_context`, `has_plans`, `plan_count`, `planning_exists`, `roadmap_exists`, `phase_req_ids`.
 
 **File paths (for <files_to_read> blocks):** `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `research_path`, `verification_path`, `uat_path`. These are null if files don't exist.
 
@@ -112,7 +112,7 @@ Answer: "What do I need to know to PLAN this phase well?"
 **Phase requirement IDs (MUST address):** {phase_req_ids}
 
 **Project instructions:** Read ./CLAUDE.md if exists — follow project-specific guidelines
-**Project skills:** Check .agents/skills/ directory (if exists) — read SKILL.md files, research should account for project skill patterns
+**Project skills:** Check .skills/ directory (if exists) — read SKILL.md files, research should account for project skill patterns
 </additional_context>
 
 <output>
@@ -136,7 +136,7 @@ Task(
 
 ## 5.5. Create Validation Strategy (if Nyquist enabled)
 
-**Skip if:** `nyquist_validation_enabled` is false from INIT JSON.
+**Skip if:** `workflow.nyquist_validation` is false in `.planning/config.json`.
 
 After researcher completes, check if RESEARCH.md contains a Validation Architecture section:
 
@@ -212,7 +212,7 @@ Planner prompt:
 **Phase requirement IDs (every ID MUST appear in a plan's `requirements` field):** {phase_req_ids}
 
 **Project instructions:** Read ./CLAUDE.md if exists — follow project-specific guidelines
-**Project skills:** Check .agents/skills/ directory (if exists) — read SKILL.md files, plans should account for project skill rules
+**Project skills:** Check .skills/ directory (if exists) — read SKILL.md files, plans should account for project skill rules
 </planning_context>
 
 <downstream_consumer>
@@ -277,7 +277,7 @@ Checker prompt:
 **Phase requirement IDs (MUST ALL be covered):** {phase_req_ids}
 
 **Project instructions:** Read ./CLAUDE.md if exists — verify plans honor project guidelines
-**Project skills:** Check .agents/skills/ directory (if exists) — verify plans account for project skill rules
+**Project skills:** Check .skills/ directory (if exists) — verify plans account for project skill rules
 </verification_context>
 
 <expected_output>

package/dist/assets/templates/workflows/quick.md

@@ -108,7 +108,7 @@ Task(
 - ./CLAUDE.md (if exists — follow project-specific guidelines)
 </files_to_read>
 
-**Project skills:** Check .agents/skills/ directory (if exists) — read SKILL.md files, plans should account for project skill rules
+**Project skills:** Check .skills/ directory (if exists) — read SKILL.md files, plans should account for project skill rules
 
 </planning_context>
 
@@ -259,7 +259,7 @@ Execute quick task ${next_num}.
 - ${QUICK_DIR}/${next_num}-PLAN.md (Plan)
 - .planning/STATE.md (Project state)
 - ./CLAUDE.md (Project instructions, if exists)
-- .agents/skills/ (Project skills, if exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
+- .skills/ (Project skills, if exists — list skills, read SKILL.md for each, follow relevant rules during implementation)
 </files_to_read>
 
 <constraints>