maxsimcli 3.12.0 → 4.0.0

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

@@ -12,6 +12,7 @@ You are a thinking partner, not an interviewer. The user is the visionary — yo
 
 <required_reading>
 @./references/dashboard-bridge.md
+@./references/thinking-partner.md
 </required_reading>
 
 <tool_mandate>
@@ -52,7 +53,7 @@ Every question directed at the user MUST use a structured tool. NEVER write a qu
 </downstream_awareness>
 
 <philosophy>
-**User = founder/visionary. Claude = builder.**
+**User = founder/visionary. Claude = thinking partner and builder.**
 
 The user knows:
 - How they imagine it working
@@ -67,6 +68,16 @@ The user doesn't know (and shouldn't be asked):
 - Success metrics (inferred from the work)
 
 Ask about vision and implementation choices. Capture decisions for downstream agents.
+
+**Thinking-partner behaviors (from thinking-partner.md):**
+- **Challenge vague answers** — "Cards" could mean many things. Push for specifics.
+- **Surface unstated assumptions** — "You're assuming mobile-first — is that intentional?"
+- **Propose alternatives with trade-offs** — Don't just accept first choice. Offer 2-3 options.
+- **Make consequences visible** — "Infinite scroll means no shareable page positions."
+- **Disagree constructively** — If an approach has risks, name them.
+- **Follow the thread** — Build on what they just said. Don't jump topics.
+
+Apply these behaviors within each discussion area. The user should feel like they're thinking through decisions with a collaborator, not answering a survey.
 </philosophy>
 
 <scope_guardrail>
@@ -314,6 +325,15 @@ Ask 4 questions per area before offering to continue or move on. Each answer oft
      - Loop: discuss new areas, then prompt again
    - If "I'm ready for context": Proceed to write_context
 
+**Adaptive probing (thinking-partner mode):**
+
+Within each area, adapt your questioning based on the user's certainty level:
+- **User is confident** (picks options quickly) — probe deeper: "You chose X — have you considered how that interacts with Y?"
+- **User is uncertain** (picks "Other", hedges) — propose alternatives: "Here are 3 approaches with trade-offs..."
+- **User defers** (picks "You decide") — accept but name consequences: "I'll go with X because [reason]. That means Y."
+
+Challenge decisions that may have hidden costs. If the user picks something that conflicts with an earlier decision, surface it: "Earlier you said A, but this implies B. Which takes priority?"
+
 **Question design:**
 - Options should be concrete, not abstract ("Cards" not "Option A")
 - Each answer should inform the next question
@@ -400,6 +420,70 @@ mkdir -p ".planning/phases/${padded_phase}-${phase_slug}"
 ```
 
 Write file.
+
+**Generate phase-specific artefakte:**
+
+After writing CONTEXT.md, append phase-specific entries to the project-level artefakte files.
+
+**Append to DECISIONS.md:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-append .planning/DECISIONS.md
+```
+
+Append content:
+
+```markdown
+
+## Phase [X]: [Name]
+
+| # | Decision | Rationale | Alternatives Considered | Status |
+|---|----------|-----------|------------------------|--------|
+| [next #] | [Decision from discussion] | [Why chosen] | [What else was offered] | Locked |
+```
+
+**Append to ACCEPTANCE-CRITERIA.md:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-append .planning/ACCEPTANCE-CRITERIA.md
+```
+
+Append content under "Phase-Level Criteria":
+
+```markdown
+
+### Phase [X]: [Name]
+
+- [ ] [Observable outcome from decisions — e.g., "User sees card-based layout on feed page"]
+- [ ] [Observable outcome from decisions — e.g., "Infinite scroll loads next batch on scroll"]
+- [ ] [Observable outcome from decisions — e.g., "Empty state shows onboarding prompt"]
+```
+
+**Append to NO-GOS.md (if applicable):**
+
+If any "don't do this" or "avoid this approach" decisions were made during discussion:
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs artefakte-append .planning/NO-GOS.md
+```
+
+Append content:
+
+```markdown
+
+## Phase [X]: [Name]
+
+- [Approach to avoid] -- [why, from discussion]
+```
+
+If no no-gos emerged from discussion, skip this append.
+
+**Commit artefakte updates:**
+
+```bash
+node ~/.claude/maxsim/bin/maxsim-tools.cjs commit "docs(${padded_phase}): update artefakte from phase discussion" --files .planning/DECISIONS.md .planning/ACCEPTANCE-CRITERIA.md .planning/NO-GOS.md
+```
+
 </step>
 
 <step name="confirm_creation">

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

@@ -152,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>
@@ -168,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(
@@ -275,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,6 +7,7 @@ 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>
@@ -529,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.
@@ -628,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.
@@ -991,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:
@@ -1057,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-project.md

@@ -5,6 +5,7 @@ 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>
@@ -224,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
@@ -346,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.

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

@@ -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>
@@ -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>