cclaw-cli 0.1.1 → 0.2.1

package/dist/content/skills.js

@@ -1,3 +1,4 @@
+import { RUNTIME_ROOT } from "../constants.js";
 import { stageExamples } from "./examples.js";
 import { selfImprovementBlock } from "./learnings.js";
 import { nextCclawCommand, stageAutoSubagentDispatch, stageSchema } from "./stage-schema.js";
@@ -88,6 +89,16 @@ Before starting stage execution:
 3. Load upstream artifacts required by this stage:
 ${readLines}
 4. If canonical run artifact is missing, fallback to the \`.cclaw/artifacts/\` mirror and record that fallback.
+`;
+}
+function whenNotToUseBlock(stage) {
+    const schema = stageSchema(stage);
+    if (!schema.whenNotToUse || schema.whenNotToUse.length === 0) {
+        return "";
+    }
+    return `## When Not to Use
+${schema.whenNotToUse.map((item) => `- ${item}`).join("\n")}
+
 `;
 }
 function autoSubagentDispatchBlock(stage) {
@@ -100,6 +111,9 @@ function autoSubagentDispatchBlock(stage) {
         return `| ${rule.agent} | ${rule.mode} | ${rule.when} | ${rule.purpose} | ${userGate} |`;
     })
         .join("\n");
+    const mandatory = stageSchema(stage).mandatoryDelegations;
+    const mandatoryList = mandatory.length > 0 ? mandatory.map((a) => `\`${a}\``).join(", ") : "(none — only proactive dispatch applies)";
+    const delegationLogRel = `${RUNTIME_ROOT}/runs/<activeRunId>/delegation-log.json`;
     return `## Automatic Subagent Dispatch
 
 Machine-only work should be delegated to specialist agents automatically according to the matrix below.
@@ -109,9 +123,117 @@ Machine-only work should be delegated to specialist agents automatically accordi
 ${rows}
 
 **Gate rule:** user interaction is required only for approval/override decisions. Do not ask the user to manually trigger machine-only specialist checks.
+
+## Delegation Enforcement
+
+Before completing this stage, verify that ALL mandatory delegations are recorded. If using a harness that supports Task/delegate tools, each mandatory agent must have been invoked. If the harness does not support delegation, record a waiver with reason \`harness_limitation\` in the delegation log.
+
+Mandatory agents for this stage: ${mandatoryList}. Stage transition is BLOCKED until all are **completed** or **explicitly waived** by the user (waived entries must name the agent and carry an explicit waiver reason).
+
+On session stop or stage completion, the agent should write delegation entries to \`${delegationLogRel}\` for audit.
 `;
 }
 const VERIFICATION_STAGES = ["build", "review", "ship"];
+function waveExecutionModeBlock(stage) {
+    const schema = stageSchema(stage);
+    if (!schema.waveExecutionAllowed) {
+        return "";
+    }
+    return `## Wave Execution Mode
+
+After plan approval (**WAIT_FOR_CONFIRM** / \`plan_wait_for_confirm\` satisfied), process **all tasks in the current dependency wave** sequentially: **RED → GREEN → REFACTOR** per task, recording evidence per slice. **Stop** only on **BLOCKED**, a test failure that **requires user input**, or **wave completion** (every task in the wave has the required RED / GREEN / REFACTOR evidence per the plan artifact).
+
+`;
+}
+function stageRequiresExplicitPause(schema) {
+    const pauseRules = [
+        /\bWAIT_FOR_CONFIRM\b/,
+        /Do NOT auto-advance/i,
+        /wait for explicit user approval/i,
+        /wait for explicit approval/i,
+        /explicitly pause/i
+    ];
+    const stageText = [
+        schema.hardGate,
+        ...schema.checklist,
+        ...schema.interactionProtocol,
+        ...schema.process,
+        ...schema.exitCriteria
+    ];
+    return stageText.some((line) => pauseRules.some((rule) => rule.test(line)));
+}
+function stageTransitionAutoAdvanceBlock(schema, nextCommand) {
+    if (schema.next === "done") {
+        return "";
+    }
+    if (stageRequiresExplicitPause(schema)) {
+        return `## Stage transition (autoAdvance)
+
+If project config at \`${RUNTIME_ROOT}/config.yaml\` has \`autoAdvance: true\`, treat it as advisory only. This stage has an explicit pause or confirmation rule, so do NOT auto-advance after the gates pass. Suggest the next command (\`${nextCommand}\`) only after the required confirmation is satisfied, then wait.
+
+`;
+    }
+    return `## Stage transition (autoAdvance)
+
+If project config at \`${RUNTIME_ROOT}/config.yaml\` has \`autoAdvance: true\`, proceed to the next stage automatically after all gates pass for this stage. Otherwise, suggest the next command (\`${nextCommand}\`) and wait.
+
+`;
+}
+function progressiveDisclosureBlock(stage, nextCommand) {
+    const schema = stageSchema(stage);
+    const stageSpecificRefs = {
+        brainstorm: [
+            "- `.cclaw/skills/autoplan/SKILL.md` — when the user wants brainstorm→plan orchestration in one flow",
+            "- `.cclaw/skills/learnings/SKILL.md` — to capture durable framing insights early"
+        ],
+        scope: [
+            "- `.cclaw/skills/autoplan/SKILL.md` — for coordinated premise challenge across early stages",
+            "- `.cclaw/skills/learnings/SKILL.md` — to persist rejected assumptions and constraints"
+        ],
+        design: [
+            "- `.cclaw/skills/performance/SKILL.md` — when architectural choices carry perf trade-offs",
+            "- `.cclaw/skills/security/SKILL.md` — when design choices touch auth/secrets/trust boundaries"
+        ],
+        spec: [
+            "- `.cclaw/skills/docs/SKILL.md` — for API/contract wording quality and ADR-style decision capture",
+            "- `.cclaw/skills/learnings/SKILL.md` — to preserve acceptance criteria traps and edge-case learnings"
+        ],
+        plan: [
+            "- `.cclaw/skills/subagent-dev/SKILL.md` — for specialist delegation prompts by task slice",
+            "- `.cclaw/skills/parallel-dispatch/SKILL.md` — for multi-agent review planning and reconciliation setup"
+        ],
+        test: [
+            "- `.cclaw/skills/debugging/SKILL.md` — when RED behavior is unclear or flakes appear",
+            "- `.cclaw/skills/subagent-dev/SKILL.md` — for machine-only test-slice delegation"
+        ],
+        build: [
+            "- `.cclaw/skills/debugging/SKILL.md` — for root-cause workflow when implementation fails tests",
+            "- `.cclaw/skills/performance/SKILL.md` — when implementation choices impact latency/throughput"
+        ],
+        review: [
+            "- `.cclaw/skills/security/SKILL.md` — mandatory lens for exploitable risk detection",
+            "- `.cclaw/skills/parallel-dispatch/SKILL.md` — for review-army dispatch and reconciliation discipline"
+        ],
+        ship: [
+            "- `.cclaw/skills/ci-cd/SKILL.md` — for release gates, pipeline health, and deployment guardrails",
+            "- `.cclaw/skills/docs/SKILL.md` — for release docs, migration notes, and ADR/public API updates"
+        ]
+    };
+    return `## Progressive Disclosure
+
+### Depth
+- Primary stage procedure (this file): \`.cclaw/skills/${schema.skillFolder}/SKILL.md\`
+- Orchestrator contract (gate language and handoff): \`.cclaw/commands/${stage}.md\`
+- Artifact structure baseline: \`.cclaw/templates/${schema.artifactFile}\`
+- Runtime state truth source: \`.cclaw/state/flow-state.json\` + \`.cclaw/runs/<activeRunId>/\`
+
+### See also
+- Meta routing and activation rules: \`.cclaw/skills/using-cclaw/SKILL.md\`
+- Session continuity and checkpoint behavior: \`.cclaw/skills/session/SKILL.md\`
+${stageSpecificRefs[stage].join("\n")}
+- Next-stage handoff command: \`${nextCommand}\`
+`;
+}
 function verificationBlock(stage) {
     if (!VERIFICATION_STAGES.includes(stage))
         return "";
@@ -192,6 +314,7 @@ ${schema.purpose}
 ## When to Use
 ${schema.whenToUse.map((item) => `- ${item}`).join("\n")}
 
+${whenNotToUseBlock(stage)}
 ## Inputs
 ${schema.inputs.length > 0 ? schema.inputs.map((item) => `- ${item}`).join("\n") : "- (first stage — no required inputs)"}
 
@@ -218,6 +341,7 @@ ${cognitivePatternsList(stage)}
 ## Interaction Protocol
 ${schema.interactionProtocol.map((item, i) => `${i + 1}. ${item}`).join("\n")}
 
+${waveExecutionModeBlock(stage)}
 ## Required Gates
 ${gateList}
 
@@ -248,6 +372,8 @@ ${completionStatusBlock(stage)}
 ## Verification
 ${schema.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
 
+${stageTransitionAutoAdvanceBlock(schema, nextCommand)}
+${progressiveDisclosureBlock(stage, nextCommand)}
 ${selfImprovementBlock(stage)}
 ## Handoff
 - Next command: ${nextCommand}

package/dist/content/stage-schema.d.ts

@@ -45,6 +45,7 @@ export interface StageSchema {
     hardGate: string;
     purpose: string;
     whenToUse: string[];
+    whenNotToUse: string[];
     interactionProtocol: string[];
     process: string[];
     requiredGates: StageGate[];
@@ -68,7 +69,13 @@ export interface StageSchema {
     artifactValidation: ArtifactValidation[];
     namedAntiPattern?: NamedAntiPattern;
     decisionRecordFormat?: string;
+    /** When true, stage skill includes wave auto-execute guidance (test/build). */
+    waveExecutionAllowed?: boolean;
+    /** Agent names that MUST be dispatched (or waived) before stage transition — derived from mandatory auto-subagent rows. */
+    mandatoryDelegations: string[];
 }
+/** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
+export declare function mandatoryDelegationsForStage(stage: FlowStage): string[];
 export declare function stageSchema(stage: FlowStage): StageSchema;
 export declare function orderedStageSchemas(): StageSchema[];
 export declare function stageGateIds(stage: FlowStage): string[];

package/dist/content/stage-schema.js

@@ -1,7 +1,4 @@
 import { COMMAND_FILE_ORDER } from "../constants.js";
-// ---------------------------------------------------------------------------
-// BRAINSTORM — reference: superpowers brainstorming
-// ---------------------------------------------------------------------------
 const BRAINSTORM = {
     stage: "brainstorm",
     skillFolder: "brainstorming",
@@ -14,6 +11,11 @@ const BRAINSTORM = {
         "Requirements are ambiguous or solution path is unclear",
         "Before any implementation-stage command"
     ],
+    whenNotToUse: [
+        "An approved design, spec, and plan already exist and work is in execution stages",
+        "The request is strictly branch finalization or release handoff work",
+        "The task is purely retrospective after ship with no new design decisions needed"
+    ],
     checklist: [
         "Explore project context — check files, docs, recent commits, existing behavior.",
         "Assess scope — if the request describes multiple independent subsystems, flag for decomposition before detailed questions.",
@@ -144,6 +146,11 @@ const SCOPE = {
         "Before architecture/design lock-in",
         "When ambition vs feasibility trade-off is unclear"
     ],
+    whenNotToUse: [
+        "Brainstorm has not been approved yet",
+        "Scope boundaries are already locked and user requested no scope changes",
+        "The work is a pure implementation or debugging pass within existing scope"
+    ],
     checklist: [
         "Prime Directives — Zero silent failures (every failure mode visible). Every error has a name (not 'handle errors' — name the exception). Every data flow has four paths: happy, nil input, upstream error, downstream timeout. Observability is a scope deliverable, not a post-launch add-on.",
         "Premise Challenge — Is this the right problem? Could a different framing yield a simpler or more impactful solution? What happens if we do nothing? What are we optimizing for — speed, quality, cost, user experience?",
@@ -319,6 +326,11 @@ const DESIGN = {
         "Before writing final spec and execution plan",
         "When architecture risks need explicit treatment"
     ],
+    whenNotToUse: [
+        "Scope mode and boundaries are still unresolved",
+        "The change is docs-only or metadata-only with no architecture impact",
+        "Implementation has already started and requires review instead of design lock"
+    ],
     checklist: [
         "Design Doc Check — read existing design docs, scope artifact, brainstorm artifact. If a design doc exists that covers this area, check for 'Supersedes:' and use the latest. Use upstream artifacts as source of truth.",
         "Step 0: Scope Challenge — what existing code solves sub-problems? Minimum change set? Complexity check: 8+ files or 2+ new services = complexity smell → flag for possible scope reduction.",
@@ -526,6 +538,11 @@ const SPEC = {
         "Before planning and implementation",
         "When acceptance criteria must be measurable"
     ],
+    whenNotToUse: [
+        "Design decisions are still unresolved or disputed",
+        "The task is implementation-only cleanup with unchanged behavior",
+        "You still need to challenge scope rather than author requirements"
+    ],
     checklist: [
         "Read upstream — load design artifact and scope contract. Cross-reference architecture decisions.",
         "Define measurable acceptance criteria — each criterion must be observable and falsifiable. No vague adjectives.",
@@ -640,6 +657,11 @@ const PLAN = {
         "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 test/build stages 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.",
@@ -754,6 +776,11 @@ const TEST = {
         "Before /cc-build",
         "For every behavior change in scope"
     ],
+    whenNotToUse: [
+        "Plan approval is still pending WAIT_FOR_CONFIRM",
+        "The change is docs-only and does not alter behavior",
+        "GREEN implementation has started before RED evidence"
+    ],
     checklist: [
         "Select plan slice — pick one task from the plan. Do not batch multiple tasks.",
         "Map to acceptance criterion — identify the specific spec criterion this test proves.",
@@ -838,7 +865,8 @@ const TEST = {
         { section: "RED Evidence", required: true, validationRule: "Failing test output captured per slice." },
         { section: "Acceptance Mapping", required: true, validationRule: "Each RED test links to a plan task and spec criterion." },
         { section: "Failure Analysis", required: true, validationRule: "Failure reason matches expected missing behavior." }
-    ]
+    ],
+    waveExecutionAllowed: true
 };
 // ---------------------------------------------------------------------------
 // BUILD — TDD GREEN + REFACTOR stage
@@ -855,6 +883,11 @@ const BUILD = {
         "For one accepted plan slice at a time",
         "Before review stage"
     ],
+    whenNotToUse: [
+        "RED evidence is missing or failure reason is unverified",
+        "Multiple unrelated slices are being merged into one build pass",
+        "The stage intent is review/ship sign-off rather than implementation"
+    ],
     checklist: [
         "Minimal GREEN change — implement the smallest code change that makes the RED tests pass. No extra features.",
         "Run full suite — execute ALL tests, not just the ones you wrote. The full suite must be GREEN.",
@@ -940,7 +973,8 @@ const BUILD = {
         { section: "GREEN Evidence", required: true, validationRule: "Full suite pass output captured." },
         { section: "REFACTOR Notes", required: true, validationRule: "What changed, why, behavior preservation confirmed." },
         { section: "Traceability", required: true, validationRule: "Plan task ID and spec criterion linked." }
-    ]
+    ],
+    waveExecutionAllowed: true
 };
 // ---------------------------------------------------------------------------
 // REVIEW — reference: superpowers code-review + gstack /review
@@ -957,6 +991,11 @@ const REVIEW = {
         "Before any ship action",
         "When release risk must be assessed explicitly"
     ],
+    whenNotToUse: [
+        "There is no implementation diff to review",
+        "Build stage evidence is missing or stale",
+        "The goal is direct release execution without layered quality checks"
+    ],
     checklist: [
         "Diff Scope — Run `git diff` against base branch. If no diff, exit early with APPROVED (no changes to review). Scope the review to changed files unless blast-radius analysis requires wider inspection.",
         "Change-Size Check — ~100 lines = normal. ~300 lines = consider splitting. ~1000+ lines = strongly recommend stacked PRs. Flag large diffs to the user.",
@@ -1136,6 +1175,7 @@ const REVIEW = {
         { section: "Layer 1 Verdict", required: true, validationRule: "Per-criterion pass/fail with references." },
         { section: "Layer 2 Findings", required: true, validationRule: "Each finding has severity, description, and resolution status." },
         { section: "Review Army Contract", required: true, validationRule: "Structured findings include id/severity/confidence/fingerprint/reportedBy/status with dedup reconciliation summary." },
+        { section: "Review Readiness Dashboard", required: true, validationRule: "At least 4 readiness checklist lines including blocker and recommendation status." },
         { section: "Severity Summary", required: true, validationRule: "Counts: N critical, N important, N suggestion." },
         { section: "Final Verdict", required: true, validationRule: "Exactly one of: APPROVED, APPROVED_WITH_CONCERNS, BLOCKED." }
     ],
@@ -1159,6 +1199,11 @@ const SHIP = {
         "Before creating PR/merge/final branch action",
         "When release notes and rollback plan are required"
     ],
+    whenNotToUse: [
+        "Review verdict is BLOCKED or unresolved critical findings remain",
+        "Preflight checks cannot run and no approved exception exists",
+        "The request is still design/spec/implementation work, not release handoff"
+    ],
     checklist: [
         "Validate upstream gates — verify review verdict is APPROVED or APPROVED_WITH_CONCERNS. If BLOCKED, stop immediately.",
         "Run preflight checks — tests pass, build succeeds, linter clean, type-check clean, no uncommitted changes. Every check must produce fresh output in this message.",
@@ -1167,14 +1212,14 @@ const SHIP = {
         "Generate release notes — summarize what changed, why, and what it affects. Reference spec criteria. Include: breaking changes, new dependencies, migration steps if any.",
         "Write rollback plan — trigger conditions (what tells you it is broken), rollback steps (exact commands/git operations), and verification (how to confirm rollback worked).",
         "Monitoring checklist — what should be watched after deploy? Error rates, latency, key business metrics. If no monitoring exists, flag it as a risk.",
-        "Select finalization mode — exactly ONE of: (A) merge to main locally, (B) create PR with description, (C) keep branch for later, (D) discard branch. For discard: list what will be deleted, require typed confirmation.",
+        "Select finalization mode — exactly ONE enum: (A) FINALIZE_MERGE_LOCAL, (B) FINALIZE_OPEN_PR, (C) FINALIZE_KEEP_BRANCH, (D) FINALIZE_DISCARD_BRANCH. For discard: list what will be deleted, require typed confirmation.",
         "Execute finalization — perform the selected action. For merge: verify clean merge. For PR: include structured body (summary, test plan, rollback). For discard: verify deletion.",
         "Worktree cleanup — if using git worktrees, clean up the worktree after merge/discard. Keep it only for 'keep branch' mode."
     ],
     interactionProtocol: [
         "Run preflight checks before any release action.",
         "Document release notes and rollback plan explicitly.",
-        "For finalization mode: use the Decision Protocol — present modes as labeled options (A/B/C) with consequences, mark one as (recommended), use AskQuestion/AskUserQuestion tool when available.",
+        "For finalization mode: use the Decision Protocol — present modes as labeled options (A/B/C/D) with consequences, mark one as (recommended), use AskQuestion/AskUserQuestion tool when available.",
         "Do not proceed if critical blockers remain from review.",
         "Execute the selected finalization action and verify."
     ],
@@ -1182,7 +1227,7 @@ const SHIP = {
         "Validate review and test gates.",
         "Run preflight: build, test, lint, uncommitted-changes check.",
         "Generate release notes and rollback procedure.",
-        "Choose one finalization mode: merge, PR, keep branch, discard branch.",
+        "Choose one finalization enum: FINALIZE_MERGE_LOCAL, FINALIZE_OPEN_PR, FINALIZE_KEEP_BRANCH, or FINALIZE_DISCARD_BRANCH.",
         "Execute finalization action.",
         "Write ship artifact with decision, rationale, and execution result."
     ],
@@ -1198,7 +1243,7 @@ const SHIP = {
         "Artifact written to `.cclaw/artifacts/08-ship.md`.",
         "Release notes section is complete.",
         "Rollback section includes trigger conditions, steps, and verification.",
-        "Finalization mode shows exactly one selected.",
+        "Finalization section shows exactly one selected enum token.",
         "Execution result documented."
     ],
     inputs: ["review verdict", "test/build outputs", "release context"],
@@ -1238,7 +1283,10 @@ const SHIP = {
         "Pre-Ship Checks",
         "Release Notes",
         "Rollback Plan",
-        "merge / PR / keep branch / discard branch"
+        "FINALIZE_MERGE_LOCAL",
+        "FINALIZE_OPEN_PR",
+        "FINALIZE_KEEP_BRANCH",
+        "FINALIZE_DISCARD_BRANCH"
     ],
     artifactFile: "08-ship.md",
     next: "done",
@@ -1283,7 +1331,7 @@ const SHIP = {
         { section: "Release Notes", required: true, validationRule: "What changed, why, impact. References spec criteria. Breaking changes flagged." },
         { section: "Rollback Plan", required: true, validationRule: "Trigger conditions, rollback steps (exact commands), verification steps." },
         { section: "Monitoring", required: false, validationRule: "If applicable: what metrics/logs to watch post-deploy. Risk note if no monitoring." },
-        { section: "Finalization", required: true, validationRule: "Exactly one mode selected. Execution result documented. Worktree cleaned if applicable." }
+        { section: "Finalization", required: true, validationRule: "Exactly one finalization enum token selected. Execution result documented. Worktree cleaned if applicable." }
     ]
 };
 // ---------------------------------------------------------------------------
@@ -1418,8 +1466,18 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         }
     ]
 };
+/** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
+export function mandatoryDelegationsForStage(stage) {
+    return STAGE_AUTO_SUBAGENT_DISPATCH[stage]
+        .filter((d) => d.mode === "mandatory")
+        .map((d) => d.agent);
+}
 export function stageSchema(stage) {
-    return STAGE_SCHEMA_MAP[stage];
+    const base = STAGE_SCHEMA_MAP[stage];
+    return {
+        ...base,
+        mandatoryDelegations: mandatoryDelegationsForStage(stage)
+    };
 }
 export function orderedStageSchemas() {
     return COMMAND_FILE_ORDER.map((stage) => stageSchema(stage));

package/dist/content/subagents.js

@@ -40,6 +40,25 @@ For cclaw flow stages, machine-only specialist work should auto-dispatch without
 
 Human input remains mandatory only at explicit approval gates (plan approval, user challenge resolution, release finalization mode).
 
+## Model & Harness Routing Notes
+
+### Harness routing
+
+| Harness | Delegation tool | Structured ask tool | Routing note |
+|---|---|---|---|
+| Claude | Task/delegate | AskUserQuestion | Preferred for rich multi-step delegation + explicit approvals. |
+| Cursor | Task | AskQuestion | Use option-based asks for mode/waiver decisions; keep subagent payloads concise. |
+| Codex | Task (if available) | None native | Use numbered choices in chat for approvals; keep prompts fully self-contained. |
+| OpenCode | Task (if available) | None native | Log delegation outcomes in artifacts/state explicitly; do not assume built-in ask workflows. |
+
+If delegation tooling is unavailable in the active harness, run the same controller protocol in-thread and record a delegation waiver with reason \`harness_limitation\`.
+
+### Model routing
+
+- **Use a faster model** for bounded, deterministic tasks (single slice implementation, mechanical refactors, straightforward lint/test fixes).
+- **Use a more capable model** for high-ambiguity or high-risk analysis (security review, architecture conflicts, spec contradiction resolution).
+- During review-heavy stages, prefer **mixed routing**: faster first-pass triage + escalate only high-severity/low-confidence findings.
+
 ## HARD-GATE
 
 **Never dispatch a subagent without a concrete, self-contained task description pasted into the prompt. Do not pass file references the subagent must read to understand its task.**
@@ -241,6 +260,20 @@ Implementation that touches shared source trees must remain **sequential** unles
 - **Multi-specialist review** where reviewers must not contaminate each other’s first impressions.
 - **Parallel test/log analysis** across unrelated failures (distinct subsystems).
 
+## Model & Harness Routing Notes
+
+### Harness routing
+
+- Launch all parallel Task calls in a **single message** only on harnesses that support concurrent delegation.
+- If the harness cannot safely fan out parallel delegations, run lenses sequentially and preserve the same reconciliation schema.
+- For harnesses without structured ask tools, put reconciliation decisions as explicit numbered options in chat and wait for user selection on blockers.
+
+### Model routing
+
+- **Faster model:** broad first-pass scans, duplicate detection, low-risk normalization.
+- **More capable model:** conflict reconciliation, architectural contradiction analysis, security-critical tie-breaks.
+- Escalation trigger: any finding that is \`Critical\`, contradictory across specialists, or confidence <5 with potential ship impact.
+
 ## Dispatch Protocol
 
 1. **Identify independent problem domains** (no file overlap; no shared mutable working assumptions).

package/dist/content/templates.d.ts

@@ -1,3 +1,4 @@
 export declare const ARTIFACT_TEMPLATES: Record<string, string>;
 export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship\n- Require explicit user confirmation after /plan before /test or /build\n- Keep evidence artifacts in `.cclaw/artifacts/`\n- Enforce RED before GREEN in TDD\n- Run two-layer review (spec_compliance and code_quality) before ship\n- Validate all inputs before processing \u2014 never trust external data without sanitization\n- Prefer immutable data patterns and pure functions where the language supports them\n- Follow existing repo conventions, patterns, and directory structure \u2014 match the codebase\n- Verify claims with fresh evidence: \"tests pass\" requires running tests in this message\n- Use conventional commits: `type(scope): description` (feat, fix, refactor, test, docs, chore)\n\n## MUST_NEVER\n- Skip /test and jump directly to /build\n- Ship with critical review findings\n- Start implementation during /brainstorm\n- Modify generated cclaw files manually when CLI can regenerate them\n- Commit `.cclaw/` or generated shim files\n- Expose secrets, tokens, API keys, or absolute system paths in agent output\n- Duplicate existing functionality without explicit justification \u2014 search before building\n- Bypass security checks, linting hooks, or type checking to \"move faster\"\n- Claim success (\"Done,\" \"All good,\" \"Tests pass\") without running verification in this message\n- Make changes outside the blast radius of the current task without user consent\n\n## DELEGATION\nWhen a task requires specialist knowledge (security audit, performance profiling, database review),\ndelegate to a specialized agent or skill if the harness supports it. The primary agent should:\n1. Identify the specialist domain\n2. Provide focused context (relevant files, the specific concern)\n3. Evaluate the specialist output before acting on it \u2014 do not blindly apply recommendations\n";
+export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship.\n- Read `.cclaw/state/flow-state.json` before acting; continue from current stage when active.\n- Use `/cc-next` only after required gates pass; never bypass explicit pause/approval rules.\n- Keep evidence in `.cclaw/artifacts/` and canonical run copies in `.cclaw/runs/<activeRunId>/artifacts/`.\n- For machine-only checks in design/plan/test/build/review/ship, dispatch required specialists automatically when tooling supports it.\n- Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).\n- Treat `.cclaw/skills/using-cclaw/SKILL.md` as routing source of truth; load contextual utility skills only when their triggers apply.\n";
 export declare function buildRulesJson(): Record<string, unknown>;