maxsimcli 4.8.0 → 4.9.0

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

@@ -1,11 +1,11 @@
 <sanity_check>
 Before executing any step in this workflow, verify:
-1. The current directory contains a `.planning/` folder — if not, stop and tell the user to run `/maxsim:new-project` first.
+1. The current directory contains a `.planning/` folder — if not, stop and tell the user to run `/maxsim:init` first.
 2. `.planning/ROADMAP.md` exists — if not, stop and tell the user to initialize the project.
 </sanity_check>
 
 <purpose>
-Create executable phase prompts (PLAN.md files) for a roadmap phase with integrated research and verification. Default flow: Research (if needed) -> Plan -> Verify -> Done. Orchestrates maxsim-phase-researcher, maxsim-planner, and maxsim-plan-checker agents with a revision loop (max 3 iterations).
+Create executable phase prompts (PLAN.md files) for a roadmap phase with integrated research and verification. Default flow: Research (if needed) -> Plan -> Verify -> Done. Orchestrates researcher, planner, and planner (plan-checking mode) agents with a revision loop (max 3 iterations).
 </purpose>
 
 <required_reading>
@@ -29,7 +29,7 @@ Parse JSON for: `researcher_model`, `planner_model`, `checker_model`, `research_
 
 **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.
 
-**If `planning_exists` is false:** Error — run `/maxsim:new-project` first.
+**If `planning_exists` is false:** Error — run `/maxsim:init` first.
 
 ## 2. Parse and Normalize Arguments
 
@@ -68,7 +68,7 @@ Use AskUserQuestion:
   - "Run discuss-phase first" — Capture design decisions before planning
 
 If "Continue without context": Proceed to step 5.
-If "Run discuss-phase first": Display `/maxsim:discuss-phase {X}` and exit workflow.
+If "Run discuss-phase first": Display `/maxsim:plan {X}` (discussion stage) and exit workflow.
 
 ## 5. Handle Research
 
@@ -87,7 +87,7 @@ Display banner:
 ◆ Spawning researcher...
 ```
 
-### Spawn maxsim-phase-researcher
+### Spawn researcher
 
 ```bash
 PHASE_DESC=$(node ~/.claude/maxsim/bin/maxsim-tools.cjs roadmap get-phase "${PHASE}" | jq -r '.section')
@@ -102,7 +102,7 @@ Answer: "What do I need to know to PLAN this phase well?"
 </objective>
 
 <files_to_read>
-- {context_path} (USER DECISIONS from /maxsim:discuss-phase)
+- {context_path} (USER DECISIONS from /maxsim:plan discussion stage)
 - {requirements_path} (Project requirements)
 - {state_path} (Project decisions and history)
 </files_to_read>
@@ -122,8 +122,8 @@ Write to: {phase_dir}/{phase_num}-RESEARCH.md
 
 ```
 Task(
-  prompt="First, read ~/.claude/agents/maxsim-phase-researcher.md for your role and instructions.\n\n" + research_prompt,
-  subagent_type="general-purpose",
+  prompt=research_prompt,
+  subagent_type="researcher",
   model="{researcher_model}",
   description="Research Phase {phase}"
 )
@@ -181,7 +181,7 @@ UAT_PATH=$(echo "$INIT" | jq -r '.uat_path // empty')
 CONTEXT_PATH=$(echo "$INIT" | jq -r '.context_path // empty')
 ```
 
-## 8. Spawn maxsim-planner Agent
+## 8. Spawn planner Agent
 
 Display banner:
 ```
@@ -203,7 +203,7 @@ Planner prompt:
 - {state_path} (Project State)
 - {roadmap_path} (Roadmap)
 - {requirements_path} (Requirements)
-- {context_path} (USER DECISIONS from /maxsim:discuss-phase)
+- {context_path} (USER DECISIONS from /maxsim:plan discussion stage)
 - {research_path} (Technical Research)
 - {verification_path} (Verification Gaps - if --gaps)
 - {uat_path} (UAT Gaps - if --gaps)
@@ -216,7 +216,7 @@ Planner prompt:
 </planning_context>
 
 <downstream_consumer>
-Output consumed by /maxsim:execute-phase. Plans need:
+Output consumed by /maxsim:execute. Plans need:
 - Frontmatter (wave, depends_on, files_modified, autonomous)
 - Tasks in XML format
 - Verification criteria
@@ -235,8 +235,8 @@ Output consumed by /maxsim:execute-phase. Plans need:
 
 ```
 Task(
-  prompt="First, read ~/.claude/agents/maxsim-planner.md for your role and instructions.\n\n" + filled_prompt,
-  subagent_type="general-purpose",
+  prompt=filled_prompt,
+  subagent_type="planner",
   model="{planner_model}",
   description="Plan Phase {phase}"
 )
@@ -248,7 +248,7 @@ Task(
 - **`## CHECKPOINT REACHED`:** Present to user, get response, spawn continuation (step 12)
 - **`## PLANNING INCONCLUSIVE`:** Show attempts, offer: Add context / Retry / Manual
 
-## 10. Spawn maxsim-plan-checker Agent
+## 10. Spawn planner Agent (Plan Verification Mode)
 
 Display banner:
 ```
@@ -270,7 +270,7 @@ Checker prompt:
 - {PHASE_DIR}/*-PLAN.md (Plans to verify)
 - {roadmap_path} (Roadmap)
 - {requirements_path} (Requirements)
-- {context_path} (USER DECISIONS from /maxsim:discuss-phase)
+- {context_path} (USER DECISIONS from /maxsim:plan discussion stage)
 - {research_path} (Technical Research — includes Validation Architecture)
 </files_to_read>
 
@@ -288,8 +288,8 @@ Checker prompt:
 
 ```
 Task(
-  prompt=checker_prompt,
-  subagent_type="maxsim-plan-checker",
+  prompt="## Task: Verify plans achieve phase goal\n\n## Suggested Skills: verification-gates\n\n" + checker_prompt,
+  subagent_type="planner",
   model="{checker_model}",
   description="Verify Phase {phase} plans"
 )
@@ -317,7 +317,7 @@ Revision prompt:
 
 <files_to_read>
 - {PHASE_DIR}/*-PLAN.md (Existing plans)
-- {context_path} (USER DECISIONS from /maxsim:discuss-phase)
+- {context_path} (USER DECISIONS from /maxsim:plan discussion stage)
 </files_to_read>
 
 **Checker issues:** {structured_issues_from_checker}
@@ -332,8 +332,8 @@ Return what changed.
 
 ```
 Task(
-  prompt="First, read ~/.claude/agents/maxsim-planner.md for your role and instructions.\n\n" + revision_prompt,
-  subagent_type="general-purpose",
+  prompt=revision_prompt,
+  subagent_type="planner",
   model="{planner_model}",
   description="Revise Phase {phase} plans"
 )
@@ -396,8 +396,8 @@ Task(
     1. Read execute-phase.md from execution_context for your complete workflow
     2. Follow ALL steps: initialize, handle_branching, validate_phase, discover_and_group_plans, execute_waves, aggregate_results, close_parent_artifacts, verify_phase_goal, update_roadmap
     3. The --no-transition flag means: after verification + roadmap update, STOP and return status. Do NOT run transition.md.
-    4. When spawning executor agents, use subagent_type='maxsim-executor' with the existing @file pattern from the workflow
-    5. When spawning verifier agents, use subagent_type='maxsim-verifier'
+    4. When spawning executor agents, use subagent_type='executor' with the existing @file pattern from the workflow
+    5. When spawning verifier agents, use subagent_type='verifier'
     6. Preserve the classifyHandoffIfNeeded workaround (spot-check on that specific error)
     7. Do NOT use the Skill tool or /maxsim: commands
     </instructions>
@@ -416,14 +416,14 @@ Task(
 
   Auto-advance pipeline finished.
 
-  Next: /maxsim:discuss-phase ${NEXT_PHASE} --auto
+  Next: /maxsim:plan ${NEXT_PHASE} --auto
   ```
 - **GAPS FOUND / VERIFICATION FAILED** → Display result, stop chain:
   ```
   Auto-advance stopped: Execution needs review.
 
   Review the output above and continue manually:
-  /maxsim:execute-phase ${PHASE}
+  /maxsim:execute ${PHASE}
   ```
 
 **If neither `--auto` nor config enabled:**
@@ -454,7 +454,7 @@ Verification: {Passed | Passed with override | Skipped}
 
 **Execute Phase {X}** — run all {N} plans
 
-/maxsim:execute-phase {X}
+/maxsim:execute {X}
 
 <sub>/clear first → fresh context window</sub>
 
@@ -462,7 +462,7 @@ Verification: {Passed | Passed with override | Skipped}
 
 **Also available:**
 - cat .planning/phases/{phase-dir}/*-PLAN.md — review plans
-- /maxsim:plan-phase {X} --research — re-research first
+- /maxsim:plan {X} --research — re-research first
 
 ───────────────────────────────────────────────────────────────
 </offer_next>
@@ -473,11 +473,11 @@ Verification: {Passed | Passed with override | Skipped}
 - [ ] Phase directory created if needed
 - [ ] CONTEXT.md loaded early (step 4) and passed to ALL agents
 - [ ] Research completed (unless --skip-research or --gaps or exists)
-- [ ] maxsim-phase-researcher spawned with CONTEXT.md
+- [ ] researcher spawned with CONTEXT.md
 - [ ] Existing plans checked
-- [ ] maxsim-planner spawned with CONTEXT.md + RESEARCH.md
+- [ ] planner spawned with CONTEXT.md + RESEARCH.md
 - [ ] Plans created (PLANNING COMPLETE or CHECKPOINT handled)
-- [ ] maxsim-plan-checker spawned with CONTEXT.md
+- [ ] planner (plan-check mode) spawned with CONTEXT.md
 - [ ] Verification passed OR user override OR max iterations with user decision
 - [ ] User sees status between agent spawns
 - [ ] User knows next steps

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

@@ -0,0 +1,177 @@
+<purpose>
+Research stage sub-workflow for /maxsim:plan. Spawns the researcher agent with phase context to produce RESEARCH.md.
+
+This file is loaded by the plan.md orchestrator. It does NOT handle gate confirmations or stage routing -- the orchestrator handles that. This sub-workflow focuses ONLY on running research and validating the output.
+</purpose>
+
+<process>
+
+## Step 1: Check Prerequisites
+
+The orchestrator provides phase context. Verify we have what we need:
+
+- `phase_number`, `phase_name`, `phase_dir`, `padded_phase`, `phase_slug`
+- `researcher_model`, `research_enabled`
+- `has_research` (whether RESEARCH.md already exists)
+- `state_path`, `roadmap_path`, `requirements_path`, `context_path`
+- `phase_req_ids` (requirement IDs that this phase must address)
+- `--force-research` flag presence
+
+## Step 2: Resolve Researcher Model
+
+```bash
+RESEARCHER_MODEL=$(node .claude/maxsim/bin/maxsim-tools.cjs resolve-model researcher --raw)
+```
+
+## Step 3: Check Existing Research
+
+**If `has_research` is true AND `--force-research` is NOT set:**
+
+Research already exists. Display:
+```
+Using existing research from: {research_path}
+```
+
+Return control to orchestrator -- no need to re-research.
+
+**If `has_research` is true AND `--force-research` IS set:**
+
+Continue to Step 4 (re-research will overwrite existing RESEARCH.md).
+
+**If `has_research` is false:**
+
+Continue to Step 4.
+
+**If `research_enabled` is false AND `--force-research` is NOT set:**
+
+Research is disabled in config. Display:
+```
+Research disabled in config (workflow.research = false).
+Skipping research stage.
+```
+
+Return control to orchestrator.
+
+## Step 4: Gather Phase Context
+
+```bash
+PHASE_DESC=$(node .claude/maxsim/bin/maxsim-tools.cjs roadmap get-phase "${PHASE}" 2>/dev/null)
+```
+
+Extract the phase section/description from the JSON output for the researcher prompt.
+
+## Step 5: Spawn Researcher
+
+Display:
+```
+Researching Phase {phase_number}: {phase_name}...
+```
+
+Construct the research prompt:
+
+```markdown
+<objective>
+Research how to implement Phase {phase_number}: {phase_name}
+Answer: "What do I need to know to PLAN this phase well?"
+</objective>
+
+<files_to_read>
+- {context_path} (USER DECISIONS -- locked choices that constrain research)
+- {requirements_path} (Project requirements)
+- {state_path} (Project decisions and history)
+</files_to_read>
+
+<additional_context>
+**Phase description:** {phase_description from PHASE_DESC}
+**Phase requirement IDs (MUST address):** {phase_req_ids}
+
+**Project instructions:** Read ./CLAUDE.md if exists -- follow project-specific guidelines
+**Project skills:** Check .skills/ directory (if exists) -- read SKILL.md files, research should account for project skill patterns
+</additional_context>
+
+<output>
+Write to: {phase_dir}/{padded_phase}-RESEARCH.md
+</output>
+```
+
+Spawn the researcher:
+
+```
+Task(
+  prompt=research_prompt,
+  subagent_type="researcher",
+  model="{researcher_model}",
+  description="Research Phase {phase_number}"
+)
+```
+
+## Step 6: Handle Researcher Return
+
+Parse the researcher's return message:
+
+- **`## RESEARCH COMPLETE`:**
+  Validate RESEARCH.md was created:
+  ```bash
+  test -f "${phase_dir}/${padded_phase}-RESEARCH.md" && echo "FOUND" || echo "MISSING"
+  ```
+
+  If FOUND:
+  - If `commit_docs` is true:
+    ```bash
+    node .claude/maxsim/bin/maxsim-tools.cjs commit "docs(${padded_phase}): research phase domain" --files "${phase_dir}/${padded_phase}-RESEARCH.md"
+    ```
+  - Display confirmation:
+    ```
+    Research complete. RESEARCH.md written to {path}.
+    ```
+  - Return control to orchestrator.
+
+  If MISSING:
+  - Error: "Researcher reported complete but RESEARCH.md not found at expected path."
+  - Check for alternative paths:
+    ```bash
+    ls "${phase_dir}"/*RESEARCH* 2>/dev/null
+    ```
+  - If found elsewhere, note the actual path and continue.
+  - If truly missing, offer: retry or skip research.
+
+- **`## RESEARCH BLOCKED`:**
+  Display the blocker reason. Offer options:
+  ```
+  Research blocked: {reason}
+
+  1. Provide additional context and retry
+  2. Skip research and proceed to planning
+  3. Abort
+  ```
+  Wait for user choice.
+
+  - If "Provide context": Get additional info, re-spawn researcher with augmented prompt.
+  - If "Skip": Return to orchestrator without RESEARCH.md.
+  - If "Abort": Exit workflow.
+
+- **`## RESEARCH INCONCLUSIVE`:**
+  Display what was attempted. Offer:
+  ```
+  Research inconclusive after {N} attempts.
+
+  1. Provide more context and retry
+  2. Skip research
+  3. Abort
+  ```
+  Handle same as BLOCKED options.
+
+## Step 7: Return to Orchestrator
+
+After RESEARCH.md is validated (or research is skipped), return control to the plan.md orchestrator. Do NOT show gate confirmation or next steps -- the orchestrator handles the gate between Research and Planning.
+
+</process>
+
+<success_criteria>
+- Researcher model resolved from config
+- Existing research detected and reused (unless --force-research)
+- researcher agent spawned with full context (CONTEXT.md, requirements, state)
+- RESEARCH.md created and validated
+- Blocked/inconclusive scenarios handled with user options
+- Control returned to orchestrator without showing gate or next steps
+</success_criteria>

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

@@ -0,0 +1,231 @@
+<sanity_check>
+Before executing any step in this workflow, verify:
+1. The current directory contains a `.planning/` folder -- if not, stop and tell the user to run `/maxsim:init` first.
+2. `.planning/ROADMAP.md` exists -- if not, stop and tell the user to initialize the project.
+</sanity_check>
+
+<purpose>
+Thin orchestrator for the /maxsim:plan state machine. Detects the current stage of a phase (Discussion, Research, Planning), delegates to stage sub-workflows, shows gate confirmations between stages, and handles re-entry on already-planned phases.
+
+This file is the ORCHESTRATOR ONLY. Stage-specific logic lives in:
+- @./workflows/plan-discuss.md (Discussion stage)
+- @./workflows/plan-research.md (Research stage)
+- @./workflows/plan-create.md (Planning stage)
+</purpose>
+
+<process>
+
+## 1. Initialize
+
+Load phase state in one call:
+
+```bash
+INIT=$(node .claude/maxsim/bin/maxsim-tools.cjs init plan-phase "$PHASE")
+```
+
+Parse JSON for: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_context`, `has_research`, `has_plans`, `plan_count`, `plans`, `commit_docs`, `researcher_model`, `planner_model`, `checker_model`, `research_enabled`, `plan_checker_enabled`, `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `research_path`, `phase_req_ids`.
+
+**If `phase_found` is false:**
+```
+Phase [X] not found in roadmap.
+
+Use /maxsim:progress to see available phases.
+```
+Exit workflow.
+
+## 2. Parse Arguments
+
+Extract from $ARGUMENTS: phase number (integer or decimal like `2.1`), flags (`--force-research`, `--skip-verify`).
+
+**If no phase number:** Detect next unplanned phase from roadmap using the `plans` and `has_context`/`has_research` fields.
+
+## 3. Detect Current Stage
+
+Determine where to start based on artifacts that already exist:
+
+| Condition | Stage | Action |
+|-----------|-------|--------|
+| `plan_count > 0` | Already planned | Go to **Re-entry flow** (step 4) |
+| `has_research == true` AND `plan_count == 0` | Planning | Start at **Planning stage** (step 7) |
+| `has_context == true` AND `has_research == false` | Research | Start at **Research stage** (step 6) |
+| None of the above | Discussion | Start at **Discussion stage** (step 5) |
+
+Display detected stage:
+```
+Phase {phase_number}: {phase_name}
+Current stage: {Discussion | Research | Planning | Already planned}
+```
+
+## 4. Re-entry Flow (Already Planned)
+
+When `plan_count > 0`, the phase has existing plans. Show status and offer options.
+
+Display:
+```
+## Phase {phase_number} Already Planned
+
+**Plans:** {plan_count} plan(s)
+**Plan files:** {list of plan filenames from `plans` array}
+**Phase directory:** {phase_dir}
+
+**Options:**
+1. View existing plans
+2. Re-plan from scratch (deletes existing plans, restarts from Discussion)
+3. Execute phase -- run /maxsim:execute {phase_number}
+4. Done (exit)
+```
+
+Wait for user choice via natural conversation.
+
+- **View:** Display contents of each PLAN.md file, then re-show options.
+- **Re-plan:** Delete existing PLAN.md files, reset to Discussion stage (step 5).
+- **Execute:** Display `/maxsim:execute {phase_number}` and exit.
+- **Done:** Exit workflow.
+
+## 5. Discussion Stage
+
+Delegate to the discussion sub-workflow for full discussion logic:
+
+@./workflows/plan-discuss.md
+
+Pass context: `phase_number`, `phase_name`, `phase_dir`, `padded_phase`, `phase_slug`, `commit_docs`, `roadmap_path`, `state_path`.
+
+**After discussion completes (CONTEXT.md written):**
+
+Refresh state to pick up the newly created CONTEXT.md:
+```bash
+INIT=$(node .claude/maxsim/bin/maxsim-tools.cjs init plan-phase "$PHASE")
+```
+
+Show gate:
+```
+## Gate: Discussion Complete
+
+**Captured:** {N} decisions across {M} areas
+**Locked decisions:**
+{bullet list of key decisions from CONTEXT.md}
+
+**Claude's discretion:** {list of areas where Claude decides}
+**Context file:** {path to CONTEXT.md}
+
+Continue to research? [Yes / Review context / Re-discuss area]
+```
+
+Wait for user response via natural conversation (not AskUserQuestion).
+
+- **Yes:** Advance to Research stage (step 6).
+- **Review context:** Display CONTEXT.md contents, then re-show gate.
+- **Re-discuss area:** Loop back to discussion sub-workflow with the area to re-discuss.
+
+## 6. Research Stage
+
+Delegate to the research sub-workflow:
+
+@./workflows/plan-research.md
+
+Pass context: `phase_number`, `phase_name`, `phase_dir`, `padded_phase`, `phase_slug`, `commit_docs`, `researcher_model`, `research_enabled`, `has_research`, `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `phase_req_ids`. Also pass the `--force-research` flag if present in $ARGUMENTS.
+
+**After research completes (RESEARCH.md written or already exists):**
+
+Refresh state:
+```bash
+INIT=$(node .claude/maxsim/bin/maxsim-tools.cjs init plan-phase "$PHASE")
+```
+
+Show gate:
+```
+## Gate: Research Complete
+
+**Key findings:** {3-5 bullet summary from RESEARCH.md}
+**Confidence:** {HIGH/MEDIUM/LOW from RESEARCH.md metadata}
+**File:** {path to RESEARCH.md}
+
+Continue to planning? [Yes / Review research / Re-research]
+```
+
+Wait for user response via natural conversation.
+
+- **Yes:** Advance to Planning stage (step 7).
+- **Review research:** Display RESEARCH.md contents, then re-show gate.
+- **Re-research:** Loop back to research sub-workflow with `--force-research`.
+
+## 7. Planning Stage
+
+Delegate to the planning sub-workflow:
+
+@./workflows/plan-create.md
+
+Pass context: `phase_number`, `phase_name`, `phase_dir`, `padded_phase`, `phase_slug`, `commit_docs`, `planner_model`, `checker_model`, `plan_checker_enabled`, `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `research_path`, `phase_req_ids`. Also pass the `--skip-verify` flag if present in $ARGUMENTS.
+
+**After planning completes (PLAN.md files created):**
+
+Refresh state:
+```bash
+INIT=$(node .claude/maxsim/bin/maxsim-tools.cjs init plan-phase "$PHASE")
+```
+
+Show final gate:
+```
+## Gate: Planning Complete
+
+**Plans:** {plan_count} plan(s) in {wave_count} wave(s)
+**Wave structure:**
+| Wave | Plans | What it builds |
+|------|-------|----------------|
+{wave summary from plan frontmatter}
+
+**Plan files:** {list of PLAN.md paths}
+
+Ready to execute? Run `/maxsim:execute {phase_number}`
+```
+
+This is the final gate -- no confirmation needed. The user's next action is to run `/maxsim:execute`.
+
+## 8. Checkpoint Before /clear
+
+At any point during the workflow, if context is getting full (conversation is long, many tool calls made), recommend checkpointing before `/clear`.
+
+**Checkpoint protocol:**
+1. Post a checkpoint comment to the phase's GitHub Issue (if issue tracking is active):
+```bash
+# Use MCP tool to post checkpoint
+mcp_post_plan_comment(
+  phase_issue_number={issue_number},
+  plan_number="checkpoint",
+  plan_content="## MAXSIM Checkpoint\n\n**Command:** /maxsim:plan\n**Stage:** {current_stage} ({stage_num}/3)\n**Completed:**\n{list of completed stages with summaries}\n**Resume from:** {next_stage}\n**Timestamp:** {ISO timestamp}"
+)
+```
+
+2. Display checkpoint recommendation:
+```
+Context is filling up. Recommended: save progress and /clear.
+
+Your progress has been checkpointed. Re-run `/maxsim:plan {phase_number}` after /clear -- it will detect completed stages and resume from {next_stage}.
+```
+
+The stage detection in step 3 handles resume automatically -- completed stages produce artifacts (CONTEXT.md, RESEARCH.md, PLAN.md) that are detected on re-entry.
+
+## 9. Update State
+
+After all stages complete, update STATE.md:
+
+```bash
+node .claude/maxsim/bin/maxsim-tools.cjs state record-session \
+  --stopped-at "Phase ${PHASE} planned" \
+  --resume-file "${phase_dir}"
+```
+
+</process>
+
+<success_criteria>
+- [ ] Phase validated against roadmap
+- [ ] Current stage correctly detected from artifacts
+- [ ] Re-entry flow works for already-planned phases
+- [ ] Discussion stage delegates to plan-discuss.md sub-workflow
+- [ ] Research stage delegates to plan-research.md sub-workflow
+- [ ] Planning stage delegates to plan-create.md sub-workflow
+- [ ] Gate confirmation shown after each stage transition
+- [ ] User confirms before advancing to next stage
+- [ ] Checkpoint-before-clear pattern available
+- [ ] No stage-specific logic inline -- all delegated to sub-workflows
+</success_criteria>