cclaw-cli 0.48.29 → 0.48.31

package/dist/content/skills.js

@@ -1,22 +1,20 @@
 import { RUNTIME_ROOT, STAGE_TO_SKILL_FOLDER } from "../constants.js";
-import { STAGE_EXAMPLES_REFERENCE_DIR, stageDomainExamples, stageExamples, stageGoodBadExamples } from "./examples.js";
+import { STAGE_EXAMPLES_REFERENCE_DIR, stageExamples } from "./examples.js";
 import { STAGE_COMMON_GUIDANCE_REL_PATH } from "./stage-common-guidance.js";
 import { stageAutoSubagentDispatch, stageSchema } from "./stage-schema.js";
 const VERIFICATION_STAGES = ["tdd", "review", "ship"];
 const DECISION_PROTOCOL_PATH = `${RUNTIME_ROOT}/references/protocols/decision.md`;
 const COMPLETION_PROTOCOL_PATH = `${RUNTIME_ROOT}/references/protocols/completion.md`;
-function whenNotToUseBlock(stage, track) {
-    const schema = stageSchema(stage, track);
-    if (schema.whenNotToUse.length === 0) {
+function whenNotToUseBlock(items) {
+    if (items.length === 0) {
         return "";
     }
     return `## When Not to Use
-${schema.whenNotToUse.map((item) => `- ${item}`).join("\n")}
+${items.map((item) => `- ${item}`).join("\n")}
 
 `;
 }
-function contextLoadingBlock(stage, track) {
-    const trace = stageSchema(stage, track).crossStageTrace;
+function contextLoadingBlock(trace) {
     const readLines = trace.readsFrom.length > 0
         ? trace.readsFrom.map((value) => `- \`${value}\``).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -54,8 +52,7 @@ Mandatory delegations for this stage: ${mandatoryList}.
 Record completion/waiver in \`${delegationLogRel}\` before stage completion.
 `;
 }
-function researchPlaybooksBlock(stage, track) {
-    const playbooks = stageSchema(stage, track).researchPlaybooks ?? [];
+function researchPlaybooksBlock(playbooks) {
     if (playbooks.length === 0)
         return "";
     const rows = playbooks
@@ -70,11 +67,10 @@ and record outcomes in the stage artifact when relevant.
 ${rows}
 `;
 }
-function reviewSectionsBlock(stage, track) {
-    const schema = stageSchema(stage, track);
-    if (schema.reviewSections.length === 0)
+function reviewSectionsBlock(sectionsInput) {
+    if (sectionsInput.length === 0)
         return "";
-    const sections = schema.reviewSections
+    const sections = sectionsInput
         .map((sec) => {
         const points = sec.evaluationPoints.map((p) => `- ${p}`).join("\n");
         const title = sec.stopGate ? `${sec.title} (STOP gate)` : sec.title;
@@ -116,8 +112,7 @@ Detailed walkthrough:
 \`.cclaw/${STAGE_EXAMPLES_REFERENCE_DIR}/tdd-batch-walkthrough.md\`
 `;
 }
-function crossStageTraceBlock(stage, track) {
-    const trace = stageSchema(stage, track).crossStageTrace;
+function crossStageTraceBlock(trace) {
     const reads = trace.readsFrom.length > 0
         ? trace.readsFrom.map((r) => `- ${r}`).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -135,8 +130,7 @@ ${writes}
 Rule: ${trace.traceabilityRule}
 `;
 }
-function artifactValidationBlock(stage, track) {
-    const validations = stageSchema(stage, track).artifactValidation;
+function artifactValidationBlock(validations) {
     if (validations.length === 0)
         return "";
     const rows = validations
@@ -152,10 +146,10 @@ function artifactValidationBlock(stage, track) {
 ${rows}
 `;
 }
-function mergedAntiPatterns(schema) {
+function mergedAntiPatterns(philosophy, execution) {
     const merged = [];
     const seen = new Set();
-    for (const item of [...schema.commonRationalizations, ...schema.blockers]) {
+    for (const item of [...philosophy.commonRationalizations, ...execution.blockers]) {
         const key = item.trim().toLowerCase();
         if (seen.has(key))
             continue;
@@ -205,9 +199,9 @@ function stageSpecificSeeAlso(stage) {
     return refs[stage];
 }
 function completionParametersBlock(schema, track) {
-    const gateList = schema.requiredGates.map((g) => `\`${g.id}\``).join(", ");
-    const mandatory = schema.mandatoryDelegations.length > 0
-        ? schema.mandatoryDelegations.map((a) => `\`${a}\``).join(", ")
+    const gateList = schema.executionModel.requiredGates.map((g) => `\`${g.id}\``).join(", ");
+    const mandatory = schema.reviewLens.mandatoryDelegations.length > 0
+        ? schema.reviewLens.mandatoryDelegations.map((a) => `\`${a}\``).join(", ")
         : "none";
     const nextStage = schema.next === "done" ? "done" : schema.next;
     const nextDescription = schema.next === "done"
@@ -218,25 +212,24 @@ function completionParametersBlock(schema, track) {
 - \`stage\`: \`${schema.stage}\`
 - \`next\`: \`${nextStage}\` (${nextDescription})
 - \`gates\`: ${gateList}
-- \`artifact\`: \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`
+- \`artifact\`: \`${RUNTIME_ROOT}/artifacts/${schema.artifactRules.artifactFile}\`
 - \`mandatory delegations\`: ${mandatory}
 - \`completion helper\`: \`node .cclaw/hooks/stage-complete.mjs ${schema.stage}\`
 - Fill \`## Learnings\` before closeout: either \`- None this stage.\` or JSON bullets with required keys \`type\`, \`trigger\`, \`action\`, \`confidence\` (knowledge-schema compatible).
 - Record mandatory delegation completion/waiver in \`${RUNTIME_ROOT}/state/delegation-log.json\` with rationale as needed.
 - Use the completion helper instead of raw \`flow-state.json\` edits (legacy direct edits trigger workflow-guard warnings or strict-mode blocks).
-Apply shared completion logic from:
-\`${COMPLETION_PROTOCOL_PATH}\`
+- Completion protocol reference: \`${COMPLETION_PROTOCOL_PATH}\`
 `;
 }
 function quickStartBlock(stage, track) {
     const schema = stageSchema(stage, track);
-    const gatePreview = schema.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
+    const gatePreview = schema.executionModel.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
     return `## Quick Start
 
-1. Announce at start: "Using \`${schema.skillName}\` to ${schema.purpose}".
+1. Announce at start: "Using \`${schema.skillName}\` to ${schema.philosophy.purpose}".
 2. Obey HARD-GATE and Iron Law.
-3. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactFile}\`.
-4. Satisfy gates (${gatePreview}${schema.requiredGates.length > 3 ? ` +${schema.requiredGates.length - 3}` : ""}).
+3. Execute checklist in order and persist \`${RUNTIME_ROOT}/artifacts/${schema.artifactRules.artifactFile}\`.
+4. Satisfy gates (${gatePreview}${schema.executionModel.requiredGates.length > 3 ? ` +${schema.executionModel.requiredGates.length - 3}` : ""}).
 `;
 }
 /**
@@ -325,21 +318,26 @@ function dedupeGuidance(items, blockedBy) {
 }
 export function stageSkillMarkdown(stage, track = "standard") {
     const schema = stageSchema(stage, track);
-    const gateList = schema.requiredGates
+    const philosophy = schema.philosophy;
+    const executionModel = schema.executionModel;
+    const artifactRules = schema.artifactRules;
+    const reviewLens = schema.reviewLens;
+    const mandatoryDelegations = reviewLens.mandatoryDelegations;
+    const gateList = executionModel.requiredGates
         .map((g) => `- \`${g.id}\` — ${g.description}`)
         .join("\n");
-    const evidenceList = schema.requiredEvidence
+    const evidenceList = executionModel.requiredEvidence
         .map((e) => `- [ ] ${e}`)
         .join("\n");
-    const checklistItems = schema.checklist
+    const checklistItems = executionModel.checklist
         .map((item, i) => `${i + 1}. ${item}`)
         .join("\n");
-    const interactionFocus = dedupeGuidance(schema.interactionProtocol, [...schema.checklist, ...schema.process]).slice(0, 5);
-    const processSummary = dedupeGuidance(schema.process, schema.checklist).slice(0, 5);
-    const processNote = schema.process.length > processSummary.length
-        ? `- Follow the Checklist above for remaining execution detail (+${schema.process.length - processSummary.length} condensed step${schema.process.length - processSummary.length === 1 ? "" : "s"}).`
-        : "";
+    const interactionFocus = dedupeGuidance(executionModel.interactionProtocol, [...executionModel.checklist, ...executionModel.process]).slice(0, 5);
+    const processSummary = dedupeGuidance(executionModel.process, executionModel.checklist).slice(0, 5);
     const stageRefs = stageSpecificSeeAlso(stage);
+    const mandatoryDelegationSummary = mandatoryDelegations.length > 0
+        ? mandatoryDelegations.map((name) => `\`${name}\``).join(", ")
+        : "none";
     return `---
 name: ${schema.skillName}
 description: "${schema.skillDescription}"
@@ -349,7 +347,7 @@ description: "${schema.skillDescription}"
 
 <EXTREMELY-IMPORTANT>
 
-**IRON LAW — ${stage.toUpperCase()}:** ${schema.ironLaw}
+**IRON LAW — ${stage.toUpperCase()}:** ${philosophy.ironLaw}
 
 If you are about to violate the Iron Law, STOP. No amount of urgency, partial progress, or clever reinterpretation overrides it. Escalate via the Decision Protocol or abandon the stage.
 
@@ -357,28 +355,35 @@ If you are about to violate the Iron Law, STOP. No amount of urgency, partial pr
 
 ${quickStartBlock(stage, track)}
 
-## Overview
-${schema.purpose}
+## Philosophy
+${philosophy.purpose}
+
+## Complexity Tier
+- Active tier: \`${schema.complexityTier}\`
+- Mandatory delegations at this tier: ${mandatoryDelegationSummary}
 
 ## When to Use
-${schema.whenToUse.map((item) => `- ${item}`).join("\n")}
+${philosophy.whenToUse.map((item) => `- ${item}`).join("\n")}
+
+${whenNotToUseBlock(philosophy.whenNotToUse)}
+## HARD-GATE
+${philosophy.hardGate}
+
+## Anti-Patterns & Red Flags
+${mergedAntiPatterns(philosophy, executionModel)}
+
+## Process
+${processSummary.length > 0 ? processSummary.map((item, i) => `${i + 1}. ${item}`).join("\n") : "1. Execute the Checklist in order.\n2. Satisfy every required gate.\n3. Complete verification before stage closeout."}
 
-${whenNotToUseBlock(stage, track)}
 ## Inputs
-${schema.inputs.length > 0 ? schema.inputs.map((item) => `- ${item}`).join("\n") : "- (first stage — no required inputs)"}
+${executionModel.inputs.length > 0 ? executionModel.inputs.map((item) => `- ${item}`).join("\n") : "- (first stage — no required inputs)"}
 
 ## Required Context
-${schema.requiredContext.length > 0 ? schema.requiredContext.map((item) => `- ${item}`).join("\n") : "- None beyond this skill"}
+${executionModel.requiredContext.length > 0 ? executionModel.requiredContext.map((item) => `- ${item}`).join("\n") : "- None beyond this skill"}
 
-${contextLoadingBlock(stage, track)}
+${contextLoadingBlock(artifactRules.crossStageTrace)}
 ${autoSubagentDispatchBlock(stage, track)}
-${researchPlaybooksBlock(stage, track)}
-
-## Outputs
-${schema.outputs.map((item) => `- ${item}`).join("\n")}
-
-## HARD-GATE
-${schema.hardGate}
+${researchPlaybooksBlock(executionModel.researchPlaybooks ?? [])}
 
 ## Checklist
 
@@ -386,15 +391,12 @@ You MUST complete these steps in order:
 
 ${checklistItems}
 
-${stageGoodBadExamples(stage)}
-${stageDomainExamples(stage)}
 ${stageExamples(stage)}
 
 ## Interaction Protocol
 ${interactionFocus.length > 0 ? interactionFocus.map((item, i) => `${i + 1}. ${item}`).join("\n") : "- Keep communication concise and decision-focused; rely on the Checklist for execution order."}
 
-Shared decision/ask-user protocol:
-\`${DECISION_PROTOCOL_PATH}\`
+Decision protocol reference: \`${DECISION_PROTOCOL_PATH}\`
 
 ${batchExecutionModeBlock(stage, track)}
 ## Required Gates
@@ -403,22 +405,24 @@ ${gateList}
 ## Required Evidence
 ${evidenceList}
 
-## Process
-${processSummary.length > 0 ? processSummary.map((item, i) => `${i + 1}. ${item}`).join("\n") : "1. Execute the Checklist in order.\n2. Satisfy every required gate.\n3. Complete verification before stage closeout."}
-${processNote.length > 0 ? `\n${processNote}` : ""}
-
-${reviewSectionsBlock(stage, track)}
 ${verificationBlock(stage)}
-${crossStageTraceBlock(stage, track)}
-${artifactValidationBlock(stage, track)}
-
-## Anti-Patterns & Red Flags
-${mergedAntiPatterns(schema)}
 
 ## Verification
-${schema.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
+${executionModel.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
 
 ${completionParametersBlock(schema, track)}
+## Artifact Rules
+- Artifact target: \`${RUNTIME_ROOT}/artifacts/${artifactRules.artifactFile}\`
+
+${crossStageTraceBlock(artifactRules.crossStageTrace)}
+${artifactValidationBlock(artifactRules.artifactValidation)}
+
+## Review Lens
+## Outputs
+${reviewLens.outputs.map((item) => `- ${item}`).join("\n")}
+
+${reviewSectionsBlock(reviewLens.reviewSections)}
+
 ## Shared Stage Guidance
 See:
 - \`${STAGE_COMMON_GUIDANCE_REL_PATH}\`

package/dist/content/stages/plan.js

@@ -2,153 +2,163 @@
 // PLAN
 // ---------------------------------------------------------------------------
 export const PLAN = {
+    schemaShape: "v2",
     stage: "plan",
+    complexityTier: "standard",
     skillFolder: "planning-and-task-breakdown",
     skillName: "planning-and-task-breakdown",
     skillDescription: "Execution planning stage with strict confirmation gate before implementation.",
-    hardGate: "Do NOT write code or tests. Planning only. This stage produces a task graph and execution order. WAIT_FOR_CONFIRM before any handoff to implementation.",
-    ironLaw: "EVERY TASK IS 2–5 MINUTES, FULLY SPELLED OUT, AND CARRIES A STABLE ID — NO PLACEHOLDERS, NO ‘ETC.’.",
-    purpose: "Create small executable tasks with dependencies and pause for explicit user confirmation.",
-    whenToUse: [
-        "After spec approval",
-        "Before writing tests or implementation",
-        "When delivery path and dependency order are needed"
-    ],
-    whenNotToUse: [
-        "Specification is unapproved or lacks measurable acceptance criteria",
-        "Execution is already in TDD stage with active slice evidence",
-        "The request is only release packaging with no task decomposition needed"
-    ],
-    checklist: [
-        "Read upstream — load spec, design, and scope artifacts. Cross-reference acceptance criteria.",
-        "Build dependency graph — identify task ordering, parallel opportunities, and blocking dependencies.",
-        "Group tasks into dependency batches — batch N+1 cannot start until batch N has verification evidence.",
-        "Slice into vertical tasks — each task targets 2-5 minutes, produces one testable outcome, and touches one coherent area.",
-        "Attach verification — every task has an acceptance criterion mapping and a concrete verification command.",
-        "Annotate slice-review metadata — if `.cclaw/config.yaml::sliceReview.enabled` is true, every task row additionally carries `touchCount` (rough number of files expected to change) and `touchPaths` (glob hints, e.g. `migrations/**`, `src/auth/**`). A task may set `highRisk: true` to force a review pass regardless of thresholds. These fields feed the TDD stage's Per-Slice Review checkpoint; when `sliceReview` is disabled they are optional.",
-        "Map scope Locked Decisions — every D-XX from scope is referenced by at least one plan task (or explicitly marked deferred with reason).",
-        "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
-        "Define checkpoints — mark points where progress should be validated before continuing.",
-        "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc-next`."
-    ],
-    interactionProtocol: [
-        "Plan in read-only mode relative to implementation.",
-        "Split work into small vertical slices (target 2-5 minute tasks).",
-        "Publish explicit dependency batches with entry and exit checks for each batch.",
-        "Attach verification step to every task.",
-        "Preserve locked scope boundaries: no silent scope reduction language in task rows.",
-        "Enforce WAIT_FOR_CONFIRM: present the plan summary with options (A) Approve / (B) Revise / (C) Reject.",
-        "**STOP.** Do NOT proceed until user explicitly approves.",
-        "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` must be marked completed or explicitly waived in `.cclaw/state/delegation-log.json`. Then close the stage via `node .cclaw/hooks/stage-complete.mjs plan` and tell the user to run `/cc-next`."
-    ],
-    process: [
-        "Build dependency graph and ordered slices.",
-        "Group slices into execution batches and define gate criteria per batch.",
-        "Define each task with acceptance mapping and verification commands.",
-        "Trace every locked decision (D-XX) to plan tasks or explicit defer rationale.",
-        "Record checkpoints and blockers.",
-        "Write plan artifact and pause at WAIT_FOR_CONFIRM."
-    ],
-    requiredGates: [
-        { id: "plan_tasks_sliced_2_5_min", description: "Tasks are small, executable slices." },
-        { id: "plan_dependency_batches_defined", description: "Tasks are grouped into executable batches with gate checks." },
-        { id: "plan_acceptance_mapped", description: "Each task maps to a spec acceptance criterion." },
-        { id: "plan_wait_for_confirm", description: "Execution blocked until explicit user confirmation." }
-    ],
-    requiredEvidence: [
-        "Artifact written to `.cclaw/artifacts/05-plan.md`.",
-        "Task list includes acceptance mapping.",
-        "Locked decision coverage table present with D-XX trace links.",
-        "Dependency graph documented.",
-        "Dependency batches documented with batch-by-batch verification gates.",
-        "WAIT_FOR_CONFIRM status recorded."
-    ],
-    inputs: ["approved spec", "codebase context", "delivery constraints"],
-    requiredContext: [
-        "spec acceptance criteria",
-        "current architecture",
-        "known technical debt and dependencies"
-    ],
-    outputs: ["task graph", "dependency batch plan", "ordered plan", "explicit confirmation checkpoint"],
-    blockers: [
-        "tasks too broad",
-        "dependency uncertainty unresolved",
-        "batch boundaries are unclear",
-        "locked decisions from scope are not mapped to tasks",
-        "no explicit confirmation"
-    ],
-    exitCriteria: [
-        "plan quality gates complete",
-        "WAIT_FOR_CONFIRM present and unresolved until user approves",
-        "artifact ready for TDD execution",
-        "acceptance mapping complete"
-    ],
-    commonRationalizations: [
-        "Horizontal decomposition without end-to-end slices",
-        "Tasks without verification steps",
-        "Starting execution before approval",
-        "Tasks that touch multiple unrelated areas",
-        "Using placeholder tokens or scope-reduction phrases (`v1`, `for now`, `later`) in task definitions",
-        "No dependency graph",
-        "No WAIT_FOR_CONFIRM marker",
-        "No explicit dependency batches",
-        "Tasks exceed one coherent outcome",
-        "No acceptance mapping",
-        "Locked decisions are missing or not mapped",
-        "Scope-reduction language appears without explicit approved defer decision"
-    ],
-    artifactFile: "05-plan.md",
-    next: "tdd",
-    reviewSections: [
-        {
-            title: "Task Decomposition Audit",
-            evaluationPoints: [
-                "Does every task target a single coherent area (vertical slice)?",
-                "Can each task be completed in 2-5 minutes?",
-                "Does every task have an acceptance criterion link and verification command?",
-                "Are there tasks that touch multiple unrelated areas?",
-                "Would a new engineer understand and start each task within two minutes?"
-            ],
-            stopGate: true
-        },
-        {
-            title: "Batch Completeness Audit",
-            evaluationPoints: [
-                "Does every task belong to exactly one batch?",
-                "Does each batch have a verification gate?",
-                "Are batch dependencies explicit and acyclic?",
-                "Is the acceptance mapping complete — every spec criterion covered?",
-                "Are there hidden dependencies between tasks in different batches?"
-            ],
-            stopGate: true
+    philosophy: {
+        hardGate: "Do NOT write code or tests. Planning only. This stage produces a task graph and execution order. WAIT_FOR_CONFIRM before any handoff to implementation.",
+        ironLaw: "EVERY TASK IS 2–5 MINUTES, FULLY SPELLED OUT, AND CARRIES A STABLE ID — NO PLACEHOLDERS, NO ‘ETC.’.",
+        purpose: "Create small executable tasks with dependencies and pause for explicit user confirmation.",
+        whenToUse: [
+            "After spec approval",
+            "Before writing tests or implementation",
+            "When delivery path and dependency order are needed"
+        ],
+        whenNotToUse: [
+            "Specification is unapproved or lacks measurable acceptance criteria",
+            "Execution is already in TDD stage with active slice evidence",
+            "The request is only release packaging with no task decomposition needed"
+        ],
+        commonRationalizations: [
+            "Horizontal decomposition without end-to-end slices",
+            "Tasks without verification steps",
+            "Starting execution before approval",
+            "Tasks that touch multiple unrelated areas",
+            "Using placeholder tokens or scope-reduction phrases (`v1`, `for now`, `later`) in task definitions",
+            "No dependency graph",
+            "No WAIT_FOR_CONFIRM marker",
+            "No explicit dependency batches",
+            "Tasks exceed one coherent outcome",
+            "No acceptance mapping",
+            "Locked decisions are missing or not mapped",
+            "Scope-reduction language appears without explicit approved defer decision"
+        ]
+    },
+    executionModel: {
+        checklist: [
+            "Read upstream — load spec, design, and scope artifacts. Cross-reference acceptance criteria.",
+            "Build dependency graph — identify task ordering, parallel opportunities, and blocking dependencies.",
+            "Group tasks into dependency batches — batch N+1 cannot start until batch N has verification evidence.",
+            "Slice into vertical tasks — each task targets 2-5 minutes, produces one testable outcome, and touches one coherent area.",
+            "Attach verification — every task has an acceptance criterion mapping and a concrete verification command.",
+            "Annotate slice-review metadata — if `.cclaw/config.yaml::sliceReview.enabled` is true, every task row additionally carries `touchCount` (rough number of files expected to change) and `touchPaths` (glob hints, e.g. `migrations/**`, `src/auth/**`). A task may set `highRisk: true` to force a review pass regardless of thresholds. These fields feed the TDD stage's Per-Slice Review checkpoint; when `sliceReview` is disabled they are optional.",
+            "Map scope Locked Decisions — every D-XX from scope is referenced by at least one plan task (or explicitly marked deferred with reason).",
+            "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
+            "Define checkpoints — mark points where progress should be validated before continuing.",
+            "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc-next`."
+        ],
+        interactionProtocol: [
+            "Plan in read-only mode relative to implementation.",
+            "Split work into small vertical slices (target 2-5 minute tasks).",
+            "Publish explicit dependency batches with entry and exit checks for each batch.",
+            "Attach verification step to every task.",
+            "Preserve locked scope boundaries: no silent scope reduction language in task rows.",
+            "Enforce WAIT_FOR_CONFIRM: present the plan summary with options (A) Approve / (B) Revise / (C) Reject.",
+            "**STOP.** Do NOT proceed until user explicitly approves.",
+            "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` must be marked completed or explicitly waived in `.cclaw/state/delegation-log.json`. Then close the stage via `node .cclaw/hooks/stage-complete.mjs plan` and tell the user to run `/cc-next`."
+        ],
+        process: [
+            "Build dependency graph and ordered slices.",
+            "Group slices into execution batches and define gate criteria per batch.",
+            "Define each task with acceptance mapping and verification commands.",
+            "Trace every locked decision (D-XX) to plan tasks or explicit defer rationale.",
+            "Record checkpoints and blockers.",
+            "Write plan artifact and pause at WAIT_FOR_CONFIRM."
+        ],
+        requiredGates: [
+            { id: "plan_tasks_sliced_2_5_min", description: "Tasks are small, executable slices." },
+            { id: "plan_dependency_batches_defined", description: "Tasks are grouped into executable batches with gate checks." },
+            { id: "plan_acceptance_mapped", description: "Each task maps to a spec acceptance criterion." },
+            { id: "plan_wait_for_confirm", description: "Execution blocked until explicit user confirmation." }
+        ],
+        requiredEvidence: [
+            "Artifact written to `.cclaw/artifacts/05-plan.md`.",
+            "Task list includes acceptance mapping.",
+            "Locked decision coverage table present with D-XX trace links.",
+            "Dependency graph documented.",
+            "Dependency batches documented with batch-by-batch verification gates.",
+            "WAIT_FOR_CONFIRM status recorded."
+        ],
+        inputs: ["approved spec", "codebase context", "delivery constraints"],
+        requiredContext: [
+            "spec acceptance criteria",
+            "current architecture",
+            "known technical debt and dependencies"
+        ],
+        blockers: [
+            "tasks too broad",
+            "dependency uncertainty unresolved",
+            "batch boundaries are unclear",
+            "locked decisions from scope are not mapped to tasks",
+            "no explicit confirmation"
+        ],
+        exitCriteria: [
+            "plan quality gates complete",
+            "WAIT_FOR_CONFIRM present and unresolved until user approves",
+            "artifact ready for TDD execution",
+            "acceptance mapping complete"
+        ]
+    },
+    artifactRules: {
+        artifactFile: "05-plan.md",
+        completionStatus: ["DONE", "DONE_WITH_CONCERNS", "BLOCKED"],
+        crossStageTrace: {
+            readsFrom: [".cclaw/artifacts/04-spec.md", ".cclaw/artifacts/03-design-<slug>.md", ".cclaw/artifacts/02-scope-<slug>.md"],
+            writesTo: [".cclaw/artifacts/05-plan.md"],
+            traceabilityRule: "Every task must trace to a spec acceptance criterion. Every locked scope decision (D-XX) must trace to at least one plan task or explicit defer rationale. Every downstream RED test must trace to a plan task."
         },
-        {
-            title: "Five-Minute Budget + No-Placeholders Audit",
-            evaluationPoints: [
-                "Does every task carry an explicit minutes estimate (e.g. `[~3m]`) and does every estimate fit the 2-to-5-minute budget? Estimates >5 minutes must be split.",
-                "Are all file paths, test commands, and verification commands copy-pasteable as written — no `TODO`, `TBD`, `FIXME`, `<fill-in>`, `<your-*-here>`, `xxx`, or ellipsis standing in for omitted args?",
-                "Does every acceptance-criterion reference resolve to a real R# / AC-### in the spec (not a blank link)?",
-                "If an estimate is genuinely uncertain (first-time integration, unfamiliar library), is the uncertainty named explicitly and scheduled as a spike task in batch 0, rather than hidden behind a large estimate?"
-            ],
-            stopGate: true
-        }
-    ],
-    completionStatus: ["DONE", "DONE_WITH_CONCERNS", "BLOCKED"],
-    crossStageTrace: {
-        readsFrom: [".cclaw/artifacts/04-spec.md", ".cclaw/artifacts/03-design-<slug>.md", ".cclaw/artifacts/02-scope-<slug>.md"],
-        writesTo: [".cclaw/artifacts/05-plan.md"],
-        traceabilityRule: "Every task must trace to a spec acceptance criterion. Every locked scope decision (D-XX) must trace to at least one plan task or explicit defer rationale. Every downstream RED test must trace to a plan task."
+        artifactValidation: [
+            { section: "Dependency Graph", required: false, validationRule: "Ordering and parallel opportunities explicit. No circular dependencies." },
+            { section: "Dependency Batches", required: true, validationRule: "Every task belongs to a batch. Each batch has an exit gate and dependency statement." },
+            { section: "Task List", required: true, validationRule: "Each task row includes ID, description, acceptance criterion, verification command, and effort estimate (S/M/L). Every task must also carry a minutes estimate within the 2-5 minute budget. When the sliceReview feature is enabled in the cclaw config, each task row additionally declares touchCount, touchPaths, and an optional highRisk flag so the TDD stage can decide whether a Per-Slice Review pass is required." },
+            { section: "Acceptance Mapping", required: true, validationRule: "Every spec criterion is covered by at least one task." },
+            { section: "Locked Decision Coverage", required: false, validationRule: "Every locked decision ID (D-XX) from scope is listed with linked task IDs or explicit defer rationale." },
+            { section: "Risk Assessment", required: false, validationRule: "If present: per-task or per-batch risk identification with likelihood, impact, and mitigation strategy." },
+            { section: "Boundary Map", required: false, validationRule: "If present: per-batch or per-task interface contracts listing what each task produces (exports) and consumes (imports) from other tasks." },
+            { section: "WAIT_FOR_CONFIRM", required: true, validationRule: "Explicit marker present. Status: pending until user approves." },
+            { section: "No-Placeholder Scan", required: false, validationRule: "Confirmation that a text scan for `TODO`, `TBD`, `FIXME`, `<fill-in>`, `<your-*-here>`, `xxx`, or bare ellipses has zero hits in the task list. A placeholder is a deferred decision masquerading as a plan." },
+            { section: "No Scope Reduction Language Scan", required: false, validationRule: "Confirmation that scope-reduction phrases (`v1`, `for now`, `later`, `temporary`, `placeholder`) are absent from task rows when locked decisions exist." }
+        ]
+    },
+    reviewLens: {
+        outputs: ["task graph", "dependency batch plan", "ordered plan", "explicit confirmation checkpoint"],
+        reviewSections: [
+            {
+                title: "Task Decomposition Audit",
+                evaluationPoints: [
+                    "Does every task target a single coherent area (vertical slice)?",
+                    "Can each task be completed in 2-5 minutes?",
+                    "Does every task have an acceptance criterion link and verification command?",
+                    "Are there tasks that touch multiple unrelated areas?",
+                    "Would a new engineer understand and start each task within two minutes?"
+                ],
+                stopGate: true
+            },
+            {
+                title: "Batch Completeness Audit",
+                evaluationPoints: [
+                    "Does every task belong to exactly one batch?",
+                    "Does each batch have a verification gate?",
+                    "Are batch dependencies explicit and acyclic?",
+                    "Is the acceptance mapping complete — every spec criterion covered?",
+                    "Are there hidden dependencies between tasks in different batches?"
+                ],
+                stopGate: true
+            },
+            {
+                title: "Five-Minute Budget + No-Placeholders Audit",
+                evaluationPoints: [
+                    "Does every task carry an explicit minutes estimate (e.g. `[~3m]`) and does every estimate fit the 2-to-5-minute budget? Estimates >5 minutes must be split.",
+                    "Are all file paths, test commands, and verification commands copy-pasteable as written — no `TODO`, `TBD`, `FIXME`, `<fill-in>`, `<your-*-here>`, `xxx`, or ellipsis standing in for omitted args?",
+                    "Does every acceptance-criterion reference resolve to a real R# / AC-### in the spec (not a blank link)?",
+                    "If an estimate is genuinely uncertain (first-time integration, unfamiliar library), is the uncertainty named explicitly and scheduled as a spike task in batch 0, rather than hidden behind a large estimate?"
+                ],
+                stopGate: true
+            }
+        ]
     },
-    artifactValidation: [
-        { section: "Dependency Graph", required: false, validationRule: "Ordering and parallel opportunities explicit. No circular dependencies." },
-        { section: "Dependency Batches", required: true, validationRule: "Every task belongs to a batch. Each batch has an exit gate and dependency statement." },
-        { section: "Task List", required: true, validationRule: "Each task row includes ID, description, acceptance criterion, verification command, and effort estimate (S/M/L). Every task must also carry a minutes estimate within the 2-5 minute budget. When the sliceReview feature is enabled in the cclaw config, each task row additionally declares touchCount, touchPaths, and an optional highRisk flag so the TDD stage can decide whether a Per-Slice Review pass is required." },
-        { section: "Acceptance Mapping", required: true, validationRule: "Every spec criterion is covered by at least one task." },
-        { section: "Locked Decision Coverage", required: false, validationRule: "Every locked decision ID (D-XX) from scope is listed with linked task IDs or explicit defer rationale." },
-        { section: "Risk Assessment", required: false, validationRule: "If present: per-task or per-batch risk identification with likelihood, impact, and mitigation strategy." },
-        { section: "Boundary Map", required: false, validationRule: "If present: per-batch or per-task interface contracts listing what each task produces (exports) and consumes (imports) from other tasks." },
-        { section: "WAIT_FOR_CONFIRM", required: true, validationRule: "Explicit marker present. Status: pending until user approves." },
-        { section: "No-Placeholder Scan", required: false, validationRule: "Confirmation that a text scan for `TODO`, `TBD`, `FIXME`, `<fill-in>`, `<your-*-here>`, `xxx`, or bare ellipses has zero hits in the task list. A placeholder is a deferred decision masquerading as a plan." },
-        { section: "No Scope Reduction Language Scan", required: false, validationRule: "Confirmation that scope-reduction phrases (`v1`, `for now`, `later`, `temporary`, `placeholder`) are absent from task rows when locked decisions exist." }
-    ]
+    next: "tdd",
 };