cclaw-cli 0.51.22 → 0.51.24

package/README.md

@@ -344,8 +344,9 @@ The `tdd` stage is not prose guidance. It requires:
 - optional **REFACTOR** pass with coverage preservation
 
 `/cc-next` will not advance past `tdd` until the delegation log shows the
-subagent as `completed` (or, on Codex / OpenCode, role-switched with
-`evidenceRefs` — see [Harness support](#harness-support)).
+subagent as `completed`. Codex and OpenCode use generated native subagents
+by default; a role-switch row is only a degraded fallback and must include
+`evidenceRefs` — see [Harness support](#harness-support).
 
 ---
 
@@ -391,25 +392,25 @@ closes every real gap with a documented fallback — not a silent waiver.
 |---|---|---|---|---|
 | Claude Code | full (named subagents) | `native` | full | `AskUserQuestion` |
 | Cursor | generic Task dispatcher | `generic-dispatch` | full | `AskQuestion` |
-| OpenCode | plugin / in-session | `role-switch` | plugin | `question` (permission-gated; `permission.question: "allow"`) |
-| OpenAI Codex | in-session only | `role-switch` (evidenceRefs required) | limited (Bash-only `PreToolUse`/`PostToolUse`; requires `codex_hooks` feature flag) | `request_user_input` (experimental; Plan / Collaboration mode) |
+| OpenCode | native subagents (`.opencode/agents`) | `native` | plugin | `question` (permission-gated; `permission.question: "allow"`) |
+| OpenAI Codex | native parallel subagents (`.codex/agents`) | `native` | limited (Bash-only `PreToolUse`/`PostToolUse`; requires `codex_hooks` feature flag) | `request_user_input` (experimental; Plan / Collaboration mode) |
 
 What the fallbacks mean:
 
-- `native` — Claude runs mandatory delegations in isolated subagent
-  workers; cclaw records them with `fulfillmentMode: "isolated"`.
+- `native` — Claude, OpenCode, and Codex run mandatory delegations in
+  isolated subagent workers; cclaw records them with `fulfillmentMode: "isolated"`.
 - `generic-dispatch` — Cursor has a real Task tool with a fixed
   vocabulary of `subagent_type`s (`explore`, `generalPurpose`, …).
   cclaw maps each named agent (planner / reviewer / test-author /
   security-reviewer / doc-updater) onto the generic dispatcher with a
   structured role prompt.
-- `role-switch` — OpenCode and Codex lack an isolated worker primitive.
-  The agent announces the role in-session, performs the work, and
-  records a delegation row with `fulfillmentMode: "role-switch"` and at
-  least one `evidenceRef` pointing at the artifact section that
-  captures the output. Under role-switch, a `completed` row **without**
-  evidenceRefs is classified as `missingEvidence` by `cclaw doctor` and
-  blocks stage completion.
+- `role-switch` — degraded fallback only when the active runtime cannot
+  expose its declared dispatch surface. The agent announces
+  `## cclaw role-switch: <stage>/<agent> (<mode>)`, loads
+  `.cclaw/agents/<agent>.md`, writes outputs to the stage artifact, and
+  records a delegation row with `fulfillmentMode: "role-switch"` plus at
+  least one `evidenceRef`. A role-switch `completed` row without
+  evidenceRefs is classified as `missingEvidence` by `cclaw doctor`.
 - `waiver` — reserved. Only fires auto-waivers if every installed
   harness declares it. Currently unused — v0.33 removed the old
   Codex-only auto-waiver path.

package/dist/content/core-agents.d.ts

@@ -23,7 +23,7 @@ export interface AgentDefinition {
     body: string;
 }
 /**
- * Canonical specialist roster (core-5) materialized under `.cclaw/agents/`.
+ * Canonical specialist roster materialized under `.cclaw/agents/`.
  *
  * Declared with `satisfies` so the array retains literal `name` types for
  * downstream type-level consumers (e.g. `AgentName`), while still being
@@ -39,6 +39,22 @@ export declare const CCLAW_AGENTS: readonly [{
     readonly activation: "mandatory";
     readonly relatedStages: ["brainstorm", "scope", "design", "spec", "plan"];
     readonly body: string;
+}, {
+    readonly name: "product-manager";
+    readonly description: "PROACTIVE during brainstorm/scope when product value, persona/JTBD, success metric, or why-now framing is unclear. Use for product discovery, not implementation.";
+    readonly tools: ["Read", "Grep", "Glob", "WebSearch"];
+    readonly model: "balanced";
+    readonly activation: "proactive";
+    readonly relatedStages: ["brainstorm", "scope"];
+    readonly body: string;
+}, {
+    readonly name: "critic";
+    readonly description: "PROACTIVE during brainstorm/scope/design when premises, alternatives, cost, rollback, or hidden assumptions need adversarial pressure.";
+    readonly tools: ["Read", "Grep", "Glob", "WebSearch"];
+    readonly model: "balanced";
+    readonly activation: "proactive";
+    readonly relatedStages: ["brainstorm", "scope", "design"];
+    readonly body: string;
 }, {
     readonly name: "reviewer";
     readonly description: "MANDATORY during review. MUST BE USED to run a two-pass audit: spec compliance first, then correctness/maintainability/performance/architecture.";
@@ -87,7 +103,7 @@ export declare function agentMarkdown(agent: AgentDefinition): string;
  */
 export declare function agentRoutingTable(): string;
 /**
- * Cost tier routing for the core-5 agent roster.
+ * Cost tier routing for the specialist agent roster.
  */
 export declare function agentCostTierTable(): string;
 /**

package/dist/content/core-agents.js

@@ -39,7 +39,7 @@ function activationModeSummary() {
     };
 }
 /**
- * Canonical specialist roster (core-5) materialized under `.cclaw/agents/`.
+ * Canonical specialist roster materialized under `.cclaw/agents/`.
  *
  * Declared with `satisfies` so the array retains literal `name` types for
  * downstream type-level consumers (e.g. `AgentName`), while still being
@@ -59,14 +59,56 @@ export const CCLAW_AGENTS = [
             "You are an **implementation planning specialist** (staff engineer mindset).",
             "",
             "When invoked:",
-            "1. Analyze scope and break it into concrete sub-problems.",
-            "2. Map each sub-problem to existing modules and reusable code.",
-            "3. Produce an ordered execution plan with dependencies and checks.",
-            "4. Highlight risks and unknowns that need user decisions.",
+            "1. Map upstream decisions, scope boundaries, and explicit drift before planning.",
+            "2. Break the work into concrete sub-problems with dependencies and existing-module fit.",
+            "3. Enforce one-question discipline: ask only decision-changing questions, one at a time.",
+            "4. Produce an ordered execution plan with verification checks and handoff quality notes.",
+            "5. Highlight risks and unknowns that need user decisions.",
             "",
             "**Role boundary:** planning only. Do NOT write production code."
         ].join("\n")
     },
+    {
+        name: "product-manager",
+        description: "PROACTIVE during brainstorm/scope when product value, persona/JTBD, success metric, or why-now framing is unclear. Use for product discovery, not implementation.",
+        tools: ["Read", "Grep", "Glob", "WebSearch"],
+        model: "balanced",
+        activation: "proactive",
+        relatedStages: ["brainstorm", "scope"],
+        body: [
+            "You are a **product discovery specialist**.",
+            "",
+            "Produce concise evidence for:",
+            "- persona / user and job to be done",
+            "- pain or trigger",
+            "- value hypothesis and success metric",
+            "- evidence or signal strength",
+            "- why now, do-nothing consequence, and non-goals",
+            "",
+            "For technical-maintenance work, translate this to operator/developer, failure mode, operational improvement, verification signal, do-nothing cost, and non-goals.",
+            "",
+            "**Role boundary:** frame value and problem fit. Do NOT choose implementation architecture."
+        ].join("\n")
+    },
+    {
+        name: "critic",
+        description: "PROACTIVE during brainstorm/scope/design when premises, alternatives, cost, rollback, or hidden assumptions need adversarial pressure.",
+        tools: ["Read", "Grep", "Glob", "WebSearch"],
+        model: "balanced",
+        activation: "proactive",
+        relatedStages: ["brainstorm", "scope", "design"],
+        body: [
+            "You are an **adversarial critic** for product and engineering decisions.",
+            "",
+            "Your job:",
+            "1. Attack the premise and name what could make the current direction wrong.",
+            "2. Identify cheaper, smaller, or more reversible alternatives.",
+            "3. Surface hidden assumptions, do-nothing viability, and scope creep.",
+            "4. In design, require a shadow alternative, switch trigger, failure/rescue path, and verification evidence.",
+            "",
+            "Return confirmed risks, disproven concerns, and the smallest decision-changing recommendation."
+        ].join("\n")
+    },
     {
         name: "reviewer",
         description: "MANDATORY during review. MUST BE USED to run a two-pass audit: spec compliance first, then correctness/maintainability/performance/architecture.",
@@ -91,9 +133,11 @@ export const CCLAW_AGENTS = [
             "",
             "For each finding include:",
             "- Severity: `Critical` | `Important` | `Suggestion`",
-            "- Location: `file:line`",
+            "- Location: `file:line`; if no line is possible, state the no-line reason",
             "- Problem and concrete recommendation",
             "",
+            "Also report files inspected, changed-file coverage, diagnostics run, dependency/version audit when relevant, and a no-finding attestation when no issues are found.",
+            "",
             "**Trust model:** never rely on implementer claims; verify by reading code."
         ].join("\n")
     },
@@ -118,7 +162,8 @@ export const CCLAW_AGENTS = [
             "- severity aligned to ship risk",
             "- CWE ID when possible (or UNKNOWN)",
             "- short proof-of-concept vector",
-            "- concrete control-oriented fix"
+            "- concrete control-oriented fix",
+            "- `NO_CHANGE_ATTESTATION` or `NO_SECURITY_IMPACT` with inspected surfaces when no security finding exists"
         ].join("\n")
     },
     {
@@ -131,7 +176,7 @@ export const CCLAW_AGENTS = [
         body: [
             "You are a **test-driven development** specialist.",
             "",
-            "**Iron law:** no production code without a failing test first.",
+            "**Iron law:** no production code without a failing test first during RED. In design, focus on testability and verification evidence without editing production code.",
             "",
             "Process:",
             "1. RED: write a failing test for the desired behavior.",
@@ -154,7 +199,8 @@ export const CCLAW_AGENTS = [
             "After code changes, verify and update only stale sections in:",
             "- README / setup / usage",
             "- API docs and examples",
-            "- migration and operational notes",
+            "- migration, rollout, rollback, and operational notes",
+            "- public-surface change notes tied to actual changed files",
             "",
             "Preserve existing tone and structure; avoid rewrites for style alone."
         ].join("\n")
@@ -221,13 +267,13 @@ export function agentRoutingTable() {
 `;
 }
 /**
- * Cost tier routing for the core-5 agent roster.
+ * Cost tier routing for the specialist agent roster.
  */
 export function agentCostTierTable() {
     return `| Tier | Use for | Example agents |
 |---|---|---|
 | \`deep\` | one heavy planning pass per stage | planner |
-| \`balanced\` | review and TDD specialists with stronger reasoning depth | reviewer, security-reviewer, test-author |
+| \`balanced\` | discovery, criticism, review, and TDD specialists with stronger reasoning depth | product-manager, critic, reviewer, security-reviewer, test-author |
 | \`fast\` | bounded maintenance updates with limited blast radius | doc-updater |
 `;
 }
@@ -237,7 +283,7 @@ export function agentCostTierTable() {
 export function agentsAgentsMdBlock() {
     return `### Agent Specialists
 
-cclaw materializes **5 core specialist agents** under \`.cclaw/agents/\`.
+cclaw materializes specialist agents under \`.cclaw/agents/\`, including planner, product-manager, critic, reviewer, security-reviewer, test-author, and doc-updater.
 
 ${agentRoutingTable()}
 
@@ -257,7 +303,7 @@ ${(() => {
         const mode = activationModeSummary();
         return `- **Mandatory:** ${mode.mandatory}.
 - **Proactive:** ${mode.proactive}.
-- **On-demand:** none in the core-5 roster; research playbooks are in-thread procedures.`;
+- **On-demand:** none in the specialist roster; research playbooks are in-thread procedures.`;
     })()}
 
 ### Cost-aware routing

package/dist/content/examples.js

@@ -4,11 +4,19 @@ const STAGE_EXAMPLES = {
 - **Project state:** Monorepo with CI pipeline using custom release scripts. Release checks are scattered across shell scripts with no shared validation logic.
 - **Relevant existing code/patterns:** \`scripts/pre-publish.sh\` does metadata checks. \`src/release/\` has partial validation helpers.
 
-## Problem
+## Problem Decision Record
 
-- **What we're solving:** release checks are fragile and inconsistent between CI and local runs. Invalid metadata sometimes reaches npm publish.
-- **Success criteria:** invalid release preconditions are caught before publish with explicit operator feedback, in both CI and local workflows.
-- **Constraints:** no new runtime dependencies; must work within existing CI pipeline structure.
+- **Depth:** standard
+- **Frame type:** technical-maintenance
+
+### Technical-maintenance framing
+
+- **Affected operator/developer:** release operator and package maintainer.
+- **Current failure mode:** release checks are fragile and inconsistent between CI and local runs; invalid metadata sometimes reaches npm publish.
+- **Expected operational improvement:** invalid release preconditions are caught before publish with explicit operator feedback in CI and local workflows.
+- **Verification signal:** shared release validation tests and CI release-check command fail on invalid metadata.
+- **Do-nothing cost:** continued publish risk and duplicated local/CI fixes.
+- **Non-goals:** no new runtime dependencies; no release-framework rewrite.
 
 ## Clarifying Questions
 
@@ -667,7 +675,7 @@ function exampleSummaryBullets(stage) {
 // sample in STAGE_EXAMPLES gains or loses a top-level section.
 const STAGE_EXAMPLE_SECTION_HEADINGS = {
     brainstorm: [
-        "Problem framing (problem, success, constraints)",
+        "Problem Decision Record (product or technical-maintenance framing)",
         "Candidate approaches with trade-offs",
         "Recommended direction + open questions",
         "Clarification log and decision record"
@@ -726,8 +734,8 @@ const DOMAIN_LABELS = {
 export const RESEARCH_FLEET_USAGE_EXAMPLE = [
     "Before drafting `03-design.md`, run `research/research-fleet.md` once and",
     "capture all four lenses in `.cclaw/artifacts/02a-research.md`.",
-    "Dispatch semantics by harness: Claude/Cursor = parallel subagents in one turn;",
-    "OpenCode/Codex = sequential role-switch with explicit announcements.",
+    "Dispatch semantics by harness: Claude/OpenCode/Codex = native subagents;",
+    "Cursor = generic-dispatch Task mapping; role-switch only as degraded fallback.",
     "Design must include a `Research Fleet Synthesis` section that maps each",
     "lens to concrete architecture decisions and risks."
 ].join(" ");

package/dist/content/hook-manifest.js

@@ -74,10 +74,7 @@ export const HOOK_MANIFEST = [
         bindings: {
             claude: [{ event: "PreToolUse", matcher: "Write|Edit|MultiEdit|NotebookEdit|Bash" }],
             cursor: [{ event: "preToolUse", matcher: "*" }],
-            codex: [
-                { event: "UserPromptSubmit" },
-                { event: "PreToolUse", matcher: "Bash|bash" }
-            ]
+            codex: [{ event: "PreToolUse", matcher: "Bash|bash" }]
         }
     },
     {

package/dist/content/learnings.js

@@ -78,7 +78,7 @@ Do not invent alternate stores (no markdown mirror, no SQLite, no per-stage file
 
 Exactly one JSON object per line. Required fields must appear in the order:
 \`type, trigger, action, confidence, domain, stage, origin_stage, origin_run, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`.
-Optional fields \`source\` and \`severity\` may be appended after \`project\`.
+Optional fields \`source\`, \`severity\`, \`supersedes\`, and \`superseded_by\` may be appended after \`project\`.
 
 \`\`\`json
 {"type":"pattern","trigger":"when reviewing external payloads","action":"parse through zod before touching service layer","confidence":"high","domain":"api","stage":"review","origin_stage":"review","origin_run":"payload-hardening","frequency":1,"universality":"project","maturity":"raw","created":"2026-04-14T12:00:00Z","first_seen_ts":"2026-04-14T12:00:00Z","last_seen_ts":"2026-04-14T12:00:00Z","project":"cclaw"}
@@ -103,12 +103,15 @@ Optional fields \`source\` and \`severity\` may be appended after \`project\`.
 | \`project\` | string \\| null | yes | Repo or scope name. Use \`null\` when the entry crosses projects. |
 | \`source\` | \`"stage" \\| "retro" \\| "compound" \\| "ideate" \\| "manual" \\| null\` | no | Origin channel for the entry when known. |
 | \`severity\` | \`"critical" \\| "important" \\| "suggestion"\` | no | Priority signal for compound lifts; \`critical\` enables single-hit override in compound readiness analysis. |
+| \`supersedes\` | string[] | no | Non-empty IDs/slugs of older entries this entry refreshes. Use only for clear replacements discovered during compound closeout or curation. |
+| \`superseded_by\` | string | no | Non-empty ID/slug of the newer entry that refreshes this one. Use only when marking stale guidance as replaced. |
 
 Rules:
 - No other fields beyond the table above. Extra keys are forbidden and MUST be rejected by any writer.
 - Every required-null field must be emitted explicitly as \`null\` (not omitted). This keeps the file grep-friendly.
 - Append-only: never rewrite or delete a historical line. Corrections are new
-  entries whose \`trigger\` clearly supersedes the earlier one.
+  entries whose \`trigger\` clearly supersedes the earlier one; add \`supersedes\` /
+  \`superseded_by\` only when the replacement relationship is clear.
 - Keep each entry one line. No pretty-printing. No trailing commas.
 
 ## Curation policy (target: ≤ 50 active entries)

package/dist/content/meta-skill.d.ts

@@ -1,2 +1,3 @@
 export declare const META_SKILL_NAME = "using-cclaw";
+export declare const META_SKILL_GENERATED_HELPER_SKILLS: readonly ["subagent-dev", "parallel-dispatch", "session", "iron-laws"];
 export declare function usingCclawSkillMarkdown(): string;

package/dist/content/meta-skill.js

@@ -1,6 +1,15 @@
 import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
 import { CLOSEOUT_CHAIN, closeoutChainInline, closeoutFlowMapSentence, closeoutProtocolBehaviorSentence } from "./closeout-guidance.js";
 export const META_SKILL_NAME = "using-cclaw";
+export const META_SKILL_GENERATED_HELPER_SKILLS = [
+    "subagent-dev",
+    "parallel-dispatch",
+    "session",
+    "iron-laws"
+];
+function generatedHelperSkillList() {
+    return META_SKILL_GENERATED_HELPER_SKILLS.map((name) => `\`${name}\``).join(", ");
+}
 export function usingCclawSkillMarkdown() {
     return `---
 name: using-cclaw
@@ -25,7 +34,7 @@ ${conversationLanguagePolicyMarkdown()}
 If \`.cclaw/state/flow-state.json\` exists and \`currentStage\` is set,
 load the matching stage SKILL before producing **substantive** work
 (artifact edits, code, structured clarifying questions). Do not improvise
-from memory. Load only generated helper surfaces that actually exist in this install: \`subagent-dev\`, \`parallel-dispatch\`, \`session\`, \`iron-laws\`, research playbooks, review prompts, or enabled language rule packs under \`.cclaw/rules/lang/\`. Do not invent helper-skill names beyond those generated surfaces.
+from memory. Load only generated helper surfaces that actually exist in this install: ${generatedHelperSkillList()}, research playbooks, review prompts, or enabled language rule packs under \`.cclaw/rules/lang/\`. Do not invent helper-skill names beyond those generated surfaces.
 
 Substantive vs. non-substantive:
 

package/dist/content/node-hooks.js

@@ -1636,7 +1636,7 @@ async function handleVerifyCurrentState(runtime) {
     process.stderr.write(result.stderr.trim().length > 0
       ? result.stderr
       : "[cclaw] hook: local Node runtime entrypoint is required for verify-current-state\\n");
-    return 1;
+    return mode === "strict" ? 1 : 0;
   }
   if (mode === "strict") {
     if (result.code !== 0) {

package/dist/content/seed-shelf.js

@@ -4,6 +4,8 @@ import { parse } from "yaml";
 import { RUNTIME_ROOT } from "../constants.js";
 const SEED_FILE_NAME_PATTERN = /^SEED-(\d{4}-\d{2}-\d{2})-([a-z0-9]+(?:-[a-z0-9]+)*)(?:-(\d+))?\.md$/u;
 const DEFAULT_MAX_MATCHES = 3;
+const MAX_SEED_MATCHES = 10;
+const MIN_TOKEN_OVERLAP = 2;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -189,18 +191,81 @@ export async function readSeedShelf(projectRoot) {
     entries.sort((a, b) => b.fileName.localeCompare(a.fileName));
     return entries;
 }
-export function seedMatchesPrompt(seed, prompt) {
-    const normalizedPrompt = prompt.toLowerCase().trim();
-    if (normalizedPrompt.length === 0)
-        return false;
-    if (seed.triggerWhen.length === 0)
+function normalizeMatchText(value) {
+    return value.toLowerCase().trim().replace(/\s+/gu, " ");
+}
+function tokenizeSeedText(value) {
+    if (!value)
+        return [];
+    return value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 3);
+}
+function uniqueTokens(values) {
+    return new Set(values);
+}
+function exactTriggerMatch(seed, normalizedPrompt) {
+    if (normalizedPrompt.length === 0 || seed.triggerWhen.length === 0)
         return false;
-    return seed.triggerWhen.some((trigger) => normalizedPrompt.includes(trigger.toLowerCase()));
+    return seed.triggerWhen.some((trigger) => {
+        const normalizedTrigger = normalizeMatchText(trigger);
+        return normalizedTrigger.length > 0 && normalizedPrompt.includes(normalizedTrigger);
+    });
+}
+function seedContentTokens(seed) {
+    return uniqueTokens([
+        ...tokenizeSeedText(seed.title),
+        ...tokenizeSeedText(seed.summary),
+        ...tokenizeSeedText(seed.hypothesis),
+        ...tokenizeSeedText(seed.action)
+    ]);
+}
+function tokenOverlap(seed, promptTokens) {
+    if (promptTokens.size === 0)
+        return 0;
+    const contentTokens = seedContentTokens(seed);
+    let overlap = 0;
+    for (const token of promptTokens) {
+        if (contentTokens.has(token))
+            overlap += 1;
+    }
+    return overlap;
+}
+export function seedMatchesPrompt(seed, prompt) {
+    const normalizedPrompt = normalizeMatchText(prompt);
+    if (exactTriggerMatch(seed, normalizedPrompt))
+        return true;
+    return tokenOverlap(seed, uniqueTokens(tokenizeSeedText(prompt))) >= MIN_TOKEN_OVERLAP;
 }
 export async function findMatchingSeeds(projectRoot, prompt, maxMatches = DEFAULT_MAX_MATCHES) {
     const seeds = await readSeedShelf(projectRoot);
-    const matches = seeds.filter((seed) => seedMatchesPrompt(seed, prompt));
-    return matches.slice(0, Math.max(1, maxMatches));
+    const normalizedPrompt = normalizeMatchText(prompt);
+    if (normalizedPrompt.length === 0)
+        return [];
+    const promptTokens = uniqueTokens(tokenizeSeedText(prompt));
+    const cappedMax = typeof maxMatches === "number" && Number.isFinite(maxMatches) && maxMatches > 0
+        ? Math.min(MAX_SEED_MATCHES, Math.max(1, Math.floor(maxMatches)))
+        : DEFAULT_MAX_MATCHES;
+    const ranked = seeds
+        .map((seed, index) => {
+        const exact = exactTriggerMatch(seed, normalizedPrompt);
+        const overlap = tokenOverlap(seed, promptTokens);
+        return { seed, index, exact, overlap };
+    })
+        .filter((row) => row.exact || row.overlap >= MIN_TOKEN_OVERLAP);
+    ranked.sort((a, b) => {
+        if (a.exact !== b.exact)
+            return a.exact ? -1 : 1;
+        if (b.overlap !== a.overlap)
+            return b.overlap - a.overlap;
+        const recency = b.seed.createdOn.localeCompare(a.seed.createdOn);
+        if (recency !== 0)
+            return recency;
+        return a.index - b.index;
+    });
+    return ranked.slice(0, cappedMax).map((row) => row.seed);
 }
 export function renderSeedTemplate(input) {
     const triggerWhen = [...input.triggerWhen].map((item) => item.trim()).filter((item) => item.length > 0);

package/dist/content/skills.js

@@ -61,23 +61,24 @@ function autoSubagentDispatchBlock(stage, track) {
     const rules = stageAutoSubagentDispatch(stage);
     if (rules.length === 0)
         return "";
+    const schema = stageSchema(stage, track);
     const rows = rules
         .map((rule) => {
         const userGate = rule.requiresUserGate ? "required" : "not required";
-        return `| ${rule.agent} | ${rule.mode} | ${userGate} | ${rule.when} |`;
+        return `| ${rule.agent} | ${rule.mode} | ${userGate} | ${rule.when} | ${rule.purpose} |`;
     })
         .join("\n");
-    const mandatory = stageSchema(stage, track).mandatoryDelegations;
+    const mandatory = schema.mandatoryDelegations;
     const mandatoryList = mandatory.length > 0 ? mandatory.map((a) => `\`${a}\``).join(", ") : "none";
     const delegationLogRel = `${RUNTIME_ROOT}/state/delegation-log.json`;
+    const artifactRef = `${RUNTIME_ROOT}/artifacts/${schema.artifactRules.artifactFile}`;
     return `## Automatic Subagent Dispatch
-
-| Agent | Mode | User Gate | Trigger |
-|---|---|---|---|
+| Agent | Mode | User Gate | Trigger | Purpose |
+|---|---|---|---|---|
 ${rows}
-
-Mandatory delegations for this stage: ${mandatoryList}.
-Record completion/waiver in \`${delegationLogRel}\` before stage completion.
+Mandatory: ${mandatoryList}. Record completion/waiver in \`${delegationLogRel}\` before completion.
+### Harness Dispatch Contract
+Use true harness dispatch: Claude native Task, Cursor generic dispatch, OpenCode \`.opencode/agents/<agent>.md\`, Codex \`.codex/agents/<agent>.toml\`. Run independent read-only/review agents in parallel where safe, write evidence into \`${artifactRef}\`, then append \`${delegationLogRel}\` rows with matching \`fulfillmentMode: "isolated"\` or \`"generic-dispatch"\`. Do not collapse OpenCode or Codex to role-switch by default; role-switch is degraded fallback and must carry non-empty \`evidenceRefs\`. Missing evidence blocks completion.
 `;
 }
 function researchPlaybooksBlock(playbooks) {
@@ -160,15 +161,18 @@ function batchExecutionModeBlock(stage, track) {
     const schema = stageSchema(stage, track);
     if (!schema.batchExecutionAllowed)
         return "";
+    const orderingGuidance = track === "quick"
+        ? "Use spec acceptance items / bug reproduction slices for ordering."
+        : "Use plan slices for ordering.";
     return `## Batch Execution Mode
 
 Execute the current dependency batch task-by-task (RED -> GREEN -> REFACTOR).
 Stop on BLOCKED status or when user input is required.
-Apply concise turn announces: one announce per batch boundary (or when risk/plan
+Apply concise turn announces: one announce per batch boundary (or when risk/source
 changes materially), then execute tasks without repetitive boilerplate.
 
 Detailed walkthrough:
-Use the active track's upstream artifact for ordering: plan slices on standard/medium, or spec acceptance items / bug reproduction slices on quick. Keep RED -> GREEN -> REFACTOR evidence in the TDD artifact.
+${orderingGuidance} Keep RED -> GREEN -> REFACTOR evidence in the TDD artifact.
 `;
 }
 function crossStageTraceBlock(trace) {

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

@@ -0,0 +1,2 @@
+import type { FlowStage } from "../types.js";
+export declare function stageCommandShimMarkdown(stage: FlowStage): string;

package/dist/content/stage-command.js

@@ -0,0 +1,17 @@
+import { RUNTIME_ROOT } from "../constants.js";
+import { stageSkillFolder } from "./skills.js";
+export function stageCommandShimMarkdown(stage) {
+    const skillPath = `${RUNTIME_ROOT}/skills/${stageSkillFolder(stage)}/SKILL.md`;
+    return `# /cc-${stage}
+
+This is a thin compatibility shim for the \`${stage}\` flow stage.
+
+Load and follow the authoritative stage skill:
+
+- \`${skillPath}\`
+
+Normal stage resume and advancement uses \`/cc-next\`. Use \`/cc-next\` to read
+\`.cclaw/state/flow-state.json\`, select the active stage, and advance only after
+that stage's gates pass. Do not duplicate the stage protocol here.
+`;
+}