cclaw-cli 0.46.10 → 0.46.11

package/dist/content/hook-events.js

@@ -29,7 +29,7 @@ export const HOOK_EVENTS_BY_HARNESS = {
         pre_tool_workflow_guard: "plugin tool.execute.before -> workflow-guard.sh",
         post_tool_context_monitor: "plugin tool.execute.after -> context-monitor.sh",
         stop_checkpoint: "plugin session.idle -> stop-checkpoint.sh",
-        precompact_digest: "plugin session.cleared/session.resumed hooks"
+        precompact_digest: "plugin session.compacted -> pre-compact.sh"
     },
     codex: {
         // Codex CLI v0.114+ exposes lifecycle hooks via `.codex/hooks.json`,

package/dist/content/opencode-plugin.js

@@ -240,23 +240,12 @@ export default function cclawPlugin(ctx) {
         // the system transform hook instead.
         refreshBootstrapCache();
       }
+      if (eventType === "session.compacted") {
+        await runHookScript("pre-compact.sh", eventData ?? {});
+      }
       if (eventType === "session.idle") {
         await runHookScript("stop-checkpoint.sh", { loop_count: 0 });
       }
-      if (eventType === "tool.execute.before") {
-        const toolPayload = normalizeToolPayload(eventData, undefined);
-        const promptOk = await runHookScript("prompt-guard.sh", toolPayload);
-        const workflowOk = await runHookScript("workflow-guard.sh", toolPayload);
-        if (!promptOk || !workflowOk) {
-          throw new Error(
-            "cclaw OpenCode guard blocked tool.execute.before (prompt/workflow guard non-zero exit)."
-          );
-        }
-      }
-      if (eventType === "tool.execute.after") {
-        const toolPayload = normalizeToolPayload(eventData, undefined);
-        await runHookScript("context-monitor.sh", toolPayload);
-      }
     },
     "tool.execute.before": async (input, output) => {
       const payload = normalizeToolPayload(input, output);

package/dist/content/skills.d.ts

@@ -1,8 +1,8 @@
-import type { FlowStage } from "../types.js";
+import type { FlowStage, FlowTrack } from "../types.js";
 /**
  * Long-form Batch Execution walkthrough. Rendered once into
  * \`.cclaw/references/stages/tdd-batch-walkthrough.md\` by the installer.
  */
 export declare const TDD_BATCH_WALKTHROUGH_MARKDOWN = "# TDD \u2014 Batch Execution Walkthrough\n\nDetailed RED / GREEN / REFACTOR transcript for a 3-task batch. Illustrative\nonly \u2014 do not copy the command names blindly, match them to your stack.\n\n## Batch 1 example tasks\n\n| Task ID | Description | AC | Verification |\n|---|---|---|---|\n| T-1 `[~3m]` | Add `User.emailNormalized` column | AC-1 | `npm test -- users/schema` |\n| T-2 `[~4m]` | Normalize on write in `UserRepo.save` | AC-1 | `npm test -- users/repo` |\n| T-3 `[~3m]` | Reject duplicates in `UserService.signup` | AC-2 | `npm test -- users/service` |\n\n## Execution transcript\n\n### T-1 \u2014 RED\n\n> Run: `npm test -- users/schema` \u2192 **FAIL** (missing column: `emailNormalized`). Captured the failure stack as RED evidence. No production code touched yet.\n\n### T-1 \u2014 GREEN\n\n> Added the column in the schema module. Re-ran `npm test -- users/schema` \u2192 **PASS**. Ran the full suite `npm test` \u2192 **PASS**. Captured both outputs as GREEN evidence.\n\n### T-1 \u2014 REFACTOR\n\n> Extracted the column definition into a shared `NormalizedEmail` type used by T-2/T-3. Re-ran `npm test` \u2192 **PASS**. Captured REFACTOR note: \"Extracted NormalizedEmail type to keep T-2/T-3 DRY; zero behavior change, all tests still green.\"\n\n### T-2 \u2014 RED / GREEN / REFACTOR\n\nWrite the repo test that expects normalised writes, watch it fail (RED), implement normalisation inside `UserRepo.save` only (GREEN), then refactor the normaliser out of the repo into a helper shared with T-3 (REFACTOR).\n\n### T-3 \u2014 RED / GREEN / REFACTOR\n\nWrite the service-level duplicate test that expects a rejection, watch it fail (RED), add the duplicate check in `UserService.signup` (GREEN), refactor the error message into a named constant (REFACTOR).\n\n## Batch gate check\n\nAfter T-3 REFACTOR, before declaring Batch 1 done:\n\n1. Run the full suite (`npm test`) one final time \u2192 **PASS** captured as batch-exit evidence.\n2. Verify the TDD artifact contains RED, GREEN, and REFACTOR evidence for T-1, T-2, **and** T-3. No partial batches.\n3. Only now mark Batch 1 complete. Batch 2 cannot start until this step.\n\n## When to stop mid-batch (do NOT push through)\n\n- A RED test fails for a reason you did not predict (e.g. an unrelated flaky test) \u2192 **pause**, diagnose, log an operational-self-improvement entry, and decide with the user before proceeding.\n- A GREEN step would require touching code outside the task's acceptance criterion \u2192 **pause**, the task is scoped wrong; adjust the plan or open a follow-up task.\n- The same RED failure reappears after a GREEN change \u2192 **escalate** per the 3-attempts rule; do not keep patching.\n";
 export declare function stageSkillFolder(stage: FlowStage): string;
-export declare function stageSkillMarkdown(stage: FlowStage): string;
+export declare function stageSkillMarkdown(stage: FlowStage, track?: FlowTrack): string;

package/dist/content/skills.js

@@ -5,8 +5,8 @@ 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) {
-    const schema = stageSchema(stage);
+function whenNotToUseBlock(stage, track) {
+    const schema = stageSchema(stage, track);
     if (schema.whenNotToUse.length === 0) {
         return "";
     }
@@ -15,8 +15,8 @@ ${schema.whenNotToUse.map((item) => `- ${item}`).join("\n")}
 
 `;
 }
-function contextLoadingBlock(stage) {
-    const trace = stageSchema(stage).crossStageTrace;
+function contextLoadingBlock(stage, track) {
+    const trace = stageSchema(stage, track).crossStageTrace;
     const readLines = trace.readsFrom.length > 0
         ? trace.readsFrom.map((value) => `- \`${value}\``).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -31,7 +31,7 @@ ${readLines}
    \`.cclaw/knowledge.jsonl\` when the digest is insufficient.
 `;
 }
-function autoSubagentDispatchBlock(stage) {
+function autoSubagentDispatchBlock(stage, track) {
     const rules = stageAutoSubagentDispatch(stage);
     if (rules.length === 0)
         return "";
@@ -41,7 +41,7 @@ function autoSubagentDispatchBlock(stage) {
         return `| ${rule.agent} | ${rule.mode} | ${userGate} | ${rule.when} |`;
     })
         .join("\n");
-    const mandatory = stageSchema(stage).mandatoryDelegations;
+    const mandatory = stageSchema(stage, track).mandatoryDelegations;
     const mandatoryList = mandatory.length > 0 ? mandatory.map((a) => `\`${a}\``).join(", ") : "none";
     const delegationLogRel = `${RUNTIME_ROOT}/state/delegation-log.json`;
     return `## Automatic Subagent Dispatch
@@ -54,8 +54,8 @@ Mandatory delegations for this stage: ${mandatoryList}.
 Record completion/waiver in \`${delegationLogRel}\` before stage completion.
 `;
 }
-function researchPlaybooksBlock(stage) {
-    const playbooks = stageSchema(stage).researchPlaybooks ?? [];
+function researchPlaybooksBlock(stage, track) {
+    const playbooks = stageSchema(stage, track).researchPlaybooks ?? [];
     if (playbooks.length === 0)
         return "";
     const rows = playbooks
@@ -70,8 +70,8 @@ and record outcomes in the stage artifact when relevant.
 ${rows}
 `;
 }
-function reviewSectionsBlock(stage) {
-    const schema = stageSchema(stage);
+function reviewSectionsBlock(stage, track) {
+    const schema = stageSchema(stage, track);
     if (schema.reviewSections.length === 0)
         return "";
     const sections = schema.reviewSections
@@ -103,8 +103,8 @@ Reference utility skill:
 \`.cclaw/skills/verification-before-completion/SKILL.md\`
 `;
 }
-function batchExecutionModeBlock(stage) {
-    const schema = stageSchema(stage);
+function batchExecutionModeBlock(stage, track) {
+    const schema = stageSchema(stage, track);
     if (!schema.batchExecutionAllowed)
         return "";
     return `## Batch Execution Mode
@@ -118,8 +118,8 @@ Detailed walkthrough:
 \`.cclaw/${STAGE_EXAMPLES_REFERENCE_DIR}/tdd-batch-walkthrough.md\`
 `;
 }
-function crossStageTraceBlock(stage) {
-    const trace = stageSchema(stage).crossStageTrace;
+function crossStageTraceBlock(stage, track) {
+    const trace = stageSchema(stage, track).crossStageTrace;
     const reads = trace.readsFrom.length > 0
         ? trace.readsFrom.map((r) => `- ${r}`).join("\n")
         : "- (first stage — no upstream artifacts)";
@@ -137,8 +137,8 @@ ${writes}
 Rule: ${trace.traceabilityRule}
 `;
 }
-function artifactValidationBlock(stage) {
-    const validations = stageSchema(stage).artifactValidation;
+function artifactValidationBlock(stage, track) {
+    const validations = stageSchema(stage, track).artifactValidation;
     if (validations.length === 0)
         return "";
     const rows = validations
@@ -206,7 +206,7 @@ function stageSpecificSeeAlso(stage) {
     };
     return refs[stage];
 }
-function completionParametersBlock(schema) {
+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(", ")
@@ -214,7 +214,7 @@ function completionParametersBlock(schema) {
     const nextStage = schema.next === "done" ? "done" : schema.next;
     const nextDescription = schema.next === "done"
         ? "flow complete"
-        : stageSchema(schema.next).skillDescription;
+        : stageSchema(schema.next, track).skillDescription;
     return `## Completion Parameters
 
 - \`stage\`: \`${schema.stage}\`
@@ -230,8 +230,8 @@ Apply shared completion logic from:
 \`${COMPLETION_PROTOCOL_PATH}\`
 `;
 }
-function quickStartBlock(stage) {
-    const schema = stageSchema(stage);
+function quickStartBlock(stage, track) {
+    const schema = stageSchema(stage, track);
     const gatePreview = schema.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
     return `## Quick Start
 
@@ -297,8 +297,8 @@ After T-3 REFACTOR, before declaring Batch 1 done:
 export function stageSkillFolder(stage) {
     return stageSchema(stage).skillFolder;
 }
-export function stageSkillMarkdown(stage) {
-    const schema = stageSchema(stage);
+export function stageSkillMarkdown(stage, track = "standard") {
+    const schema = stageSchema(stage, track);
     const gateList = schema.requiredGates
         .map((g) => `- \`${g.id}\` — ${g.description}`)
         .join("\n");
@@ -324,7 +324,7 @@ If you are about to violate the Iron Law, STOP. No amount of urgency, partial pr
 
 </EXTREMELY-IMPORTANT>
 
-${quickStartBlock(stage)}
+${quickStartBlock(stage, track)}
 
 ## Overview
 ${schema.purpose}
@@ -332,16 +332,16 @@ ${schema.purpose}
 ## When to Use
 ${schema.whenToUse.map((item) => `- ${item}`).join("\n")}
 
-${whenNotToUseBlock(stage)}
+${whenNotToUseBlock(stage, track)}
 ## Inputs
 ${schema.inputs.length > 0 ? schema.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"}
 
-${contextLoadingBlock(stage)}
-${autoSubagentDispatchBlock(stage)}
-${researchPlaybooksBlock(stage)}
+${contextLoadingBlock(stage, track)}
+${autoSubagentDispatchBlock(stage, track)}
+${researchPlaybooksBlock(stage, track)}
 
 ## Outputs
 ${schema.outputs.map((item) => `- ${item}`).join("\n")}
@@ -365,7 +365,7 @@ ${schema.interactionProtocol.map((item, i) => `${i + 1}. ${item}`).join("\n")}
 Shared decision/ask-user protocol:
 \`${DECISION_PROTOCOL_PATH}\`
 
-${batchExecutionModeBlock(stage)}
+${batchExecutionModeBlock(stage, track)}
 ## Required Gates
 ${gateList}
 
@@ -375,10 +375,10 @@ ${evidenceList}
 ## Process
 ${schema.process.map((item, i) => `${i + 1}. ${item}`).join("\n")}
 
-${reviewSectionsBlock(stage)}
+${reviewSectionsBlock(stage, track)}
 ${verificationBlock(stage)}
-${crossStageTraceBlock(stage)}
-${artifactValidationBlock(stage)}
+${crossStageTraceBlock(stage, track)}
+${artifactValidationBlock(stage, track)}
 
 ## Anti-Patterns & Red Flags
 ${mergedAntiPatterns(schema)}
@@ -386,7 +386,7 @@ ${mergedAntiPatterns(schema)}
 ## Verification
 ${schema.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
 
-${completionParametersBlock(schema)}
+${completionParametersBlock(schema, track)}
 ## Shared Stage Guidance
 See:
 - \`${STAGE_COMMON_GUIDANCE_REL_PATH}\`

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

@@ -1,13 +1,13 @@
-import type { FlowStage, TransitionRule } from "../types.js";
+import type { FlowStage, FlowTrack, TransitionRule } from "../types.js";
 import type { StageAutoSubagentDispatch, StageSchema } from "./stages/schema-types.js";
 export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageAutoSubagentDispatch, StageGate, StageSchema, StageSchemaInput } from "./stages/schema-types.js";
 /** 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[];
-export declare function stageRecommendedGateIds(stage: FlowStage): string[];
+export declare function stageSchema(stage: FlowStage, track?: FlowTrack): StageSchema;
+export declare function orderedStageSchemas(track?: FlowTrack): StageSchema[];
+export declare function stageGateIds(stage: FlowStage, track?: FlowTrack): string[];
+export declare function stageRecommendedGateIds(stage: FlowStage, track?: FlowTrack): string[];
 export declare function nextCclawCommand(stage: FlowStage): string;
 export declare function buildTransitionRules(): TransitionRule[];
-export declare function stagePolicyNeedles(stage: FlowStage): string[];
+export declare function stagePolicyNeedles(stage: FlowStage, track?: FlowTrack): string[];
 export declare function stageAutoSubagentDispatch(stage: FlowStage): StageAutoSubagentDispatch[];

package/dist/content/stage-schema.js

@@ -1,16 +1,6 @@
 import { COMMAND_FILE_ORDER } from "../constants.js";
 import { BRAINSTORM, SCOPE, DESIGN, SPEC, PLAN, TDD, REVIEW, SHIP } from "./stages/index.js";
-// ---------------------------------------------------------------------------
-// NOTE: The former QUESTION_FORMAT_SPEC / ERROR_BUDGET_SPEC exports were
-// hoisted into `src/content/meta-skill.ts` (Shared Decision + Tool-Use
-// Protocol). They are no longer re-exported from here to avoid duplication
-// and drift. Stage skills cite the meta-skill by path instead.
-// ---------------------------------------------------------------------------
-/**
- * Gate tiers:
- * - required: blocking for stage completion.
- * - recommended: quality signal; unmet -> DONE_WITH_CONCERNS, not BLOCKED.
- */
+import { tddStageForTrack } from "./stages/tdd.js";
 const REQUIRED_GATE_IDS = {
     brainstorm: [
         "brainstorm_approaches_compared",
@@ -39,11 +29,12 @@ const REQUIRED_GATE_IDS = {
         "plan_acceptance_mapped",
         "plan_wait_for_confirm"
     ],
-    tdd: [
+    tdd: (track) => [
         "tdd_red_test_written",
         "tdd_green_full_suite",
         "tdd_refactor_completed",
-        "tdd_verified_before_complete"
+        "tdd_verified_before_complete",
+        ...(track === "quick" ? [] : ["tdd_traceable_to_plan"])
     ],
     review: [
         "review_layer1_spec_compliance",
@@ -64,12 +55,16 @@ const REQUIRED_ARTIFACT_SECTIONS = {
     design: ["Architecture Boundaries", "Architecture Diagram", "Failure Mode Table", "Completion Dashboard"],
     spec: ["Acceptance Criteria", "Edge Cases", "Testability Map", "Approval"],
     plan: ["Task List", "Dependency Batches", "Acceptance Mapping", "WAIT_FOR_CONFIRM"],
-    tdd: ["RED Evidence", "GREEN Evidence", "REFACTOR Notes", "Traceability"],
+    tdd: ["RED Evidence", "GREEN Evidence", "REFACTOR Notes", "Traceability", "Verification Ladder"],
     review: ["Layer 1 Verdict", "Review Army Contract", "Severity Summary", "Final Verdict"],
     ship: ["Preflight Results", "Release Notes", "Rollback Plan", "Finalization"]
 };
-function tieredStageGates(stage, gates) {
-    const requiredSet = new Set(REQUIRED_GATE_IDS[stage]);
+function resolveRequiredGateIds(stage, track) {
+    const raw = REQUIRED_GATE_IDS[stage];
+    return typeof raw === "function" ? raw(track) : raw;
+}
+function tieredStageGates(stage, gates, track) {
+    const requiredSet = new Set(resolveRequiredGateIds(stage, track));
     return gates.map((gate) => {
         return {
             ...gate,
@@ -233,9 +228,9 @@ export function mandatoryDelegationsForStage(stage) {
         .filter((d) => d.mode === "mandatory")
         .map((d) => d.agent);
 }
-export function stageSchema(stage) {
-    const base = STAGE_SCHEMA_MAP[stage];
-    const tieredGates = tieredStageGates(stage, base.requiredGates);
+export function stageSchema(stage, track = "standard") {
+    const base = stage === "tdd" ? tddStageForTrack(track) : STAGE_SCHEMA_MAP[stage];
+    const tieredGates = tieredStageGates(stage, base.requiredGates, track);
     const tieredValidation = tieredArtifactValidation(stage, base.artifactValidation);
     return {
         ...base,
@@ -244,16 +239,16 @@ export function stageSchema(stage) {
         mandatoryDelegations: mandatoryDelegationsForStage(stage)
     };
 }
-export function orderedStageSchemas() {
-    return COMMAND_FILE_ORDER.map((stage) => stageSchema(stage));
+export function orderedStageSchemas(track = "standard") {
+    return COMMAND_FILE_ORDER.map((stage) => stageSchema(stage, track));
 }
-export function stageGateIds(stage) {
-    return stageSchema(stage).requiredGates
+export function stageGateIds(stage, track = "standard") {
+    return stageSchema(stage, track).requiredGates
         .filter((gate) => gate.tier === "required")
         .map((gate) => gate.id);
 }
-export function stageRecommendedGateIds(stage) {
-    return stageSchema(stage).requiredGates
+export function stageRecommendedGateIds(stage, track = "standard") {
+    return stageSchema(stage, track).requiredGates
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
 }
@@ -275,8 +270,8 @@ export function buildTransitionRules() {
     }
     return rules;
 }
-export function stagePolicyNeedles(stage) {
-    return stageSchema(stage).policyNeedles;
+export function stagePolicyNeedles(stage, track = "standard") {
+    return stageSchema(stage, track).policyNeedles;
 }
 export function stageAutoSubagentDispatch(stage) {
     return STAGE_AUTO_SUBAGENT_DISPATCH[stage];

package/dist/content/stages/tdd.d.ts

@@ -1,2 +1,4 @@
 import type { StageSchemaInput } from "./schema-types.js";
+import type { FlowTrack } from "../../types.js";
 export declare const TDD: StageSchemaInput;
+export declare function tddStageForTrack(track: FlowTrack): StageSchemaInput;

package/dist/content/stages/tdd.js

@@ -179,7 +179,7 @@ export const TDD = {
         { 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." },
-        { section: "Verification Ladder", required: false, validationRule: "If present: per-slice verification tier (static, command, behavioral, human) with evidence for highest tier reached." },
+        { section: "Verification Ladder", required: true, validationRule: "Per-slice verification tier (static, command, behavioral, human) with evidence captured for the highest tier reached this turn." },
         { section: "Coverage Targets", required: false, validationRule: "If present: per-module or per-code-type coverage thresholds with current values and measurement commands." },
         { section: "Test Pyramid Shape", required: false, validationRule: "If present: per-slice count of Small/Medium/Large tests added, to let reviewers verify the suite is not drifting top-heavy." },
         { section: "Prove-It Reproduction", required: false, validationRule: "Required for bug-fix slices: original failing reproduction test (RED without fix), passing output with fix (GREEN), and a note confirming the test fails again if the fix is reverted." },
@@ -187,3 +187,65 @@ export const TDD = {
     ],
     batchExecutionAllowed: true
 };
+function quickTrackText(value) {
+    return value
+        .replace(/\btask from the plan\b/giu, "acceptance criterion from the spec")
+        .replace(/\bplan task ID\b/giu, "acceptance criterion ID")
+        .replace(/\bplan task\b/giu, "acceptance criterion")
+        .replace(/\bplan row\b/giu, "acceptance row")
+        .replace(/\bplan slice\b/giu, "acceptance slice")
+        .replace(/\bplan artifact\b/giu, "spec artifact")
+        .replace(/\btraceable to plan slice\b/giu, "traceable to acceptance criterion")
+        .replace(/05-plan\.md/gu, "04-spec.md");
+}
+function tddQuickTrackVariant() {
+    return {
+        ...TDD,
+        skillDescription: quickTrackText(TDD.skillDescription),
+        hardGate: quickTrackText(TDD.hardGate),
+        checklist: TDD.checklist.map(quickTrackText),
+        interactionProtocol: TDD.interactionProtocol.map(quickTrackText),
+        process: TDD.process.map(quickTrackText),
+        requiredGates: TDD.requiredGates.map((gate) => gate.id === "tdd_traceable_to_plan"
+            ? { ...gate, description: "Change traceability to acceptance criterion is explicit." }
+            : gate),
+        requiredEvidence: TDD.requiredEvidence.map(quickTrackText),
+        inputs: TDD.inputs.map(quickTrackText),
+        requiredContext: ["spec artifact", "existing test patterns"],
+        policyNeedles: TDD.policyNeedles.map(quickTrackText),
+        reviewSections: TDD.reviewSections.map((section) => ({
+            ...section,
+            evaluationPoints: section.evaluationPoints.map(quickTrackText)
+        })),
+        crossStageTrace: {
+            ...TDD.crossStageTrace,
+            readsFrom: [".cclaw/artifacts/04-spec.md"],
+            traceabilityRule: "Every RED test traces to an acceptance criterion. Every GREEN change traces to a RED test. Evidence chain must be unbroken."
+        },
+        artifactValidation: TDD.artifactValidation.map((row) => {
+            if (row.section === "Acceptance Mapping") {
+                return {
+                    ...row,
+                    required: true,
+                    validationRule: "Each RED test links to a spec acceptance criterion ID (for example AC-1)."
+                };
+            }
+            if (row.section === "Traceability") {
+                return {
+                    ...row,
+                    validationRule: "Acceptance criterion IDs are linked to RED/GREEN evidence."
+                };
+            }
+            return {
+                ...row,
+                validationRule: quickTrackText(row.validationRule)
+            };
+        })
+    };
+}
+export function tddStageForTrack(track) {
+    if (track === "quick") {
+        return tddQuickTrackVariant();
+    }
+    return TDD;
+}

package/dist/doctor.js

@@ -623,6 +623,8 @@ export async function doctorChecks(projectRoot, options = {}) {
         "session-start.sh",
         "stop-checkpoint.sh",
         "run-hook.cmd",
+        "stage-complete.sh",
+        "pre-compact.sh",
         "prompt-guard.sh",
         "workflow-guard.sh",
         "context-monitor.sh"
@@ -816,10 +818,13 @@ export async function doctorChecks(projectRoot, options = {}) {
         const codexDoc = await readHookDocument(codexHooksFile);
         const codexHooks = toObject(codexDoc?.hooks) ?? {};
         const codexSessionCmds = collectHookCommands(codexHooks.SessionStart);
+        const codexUserPromptCmds = collectHookCommands(codexHooks.UserPromptSubmit);
         const codexPreCmds = collectHookCommands(codexHooks.PreToolUse);
         const codexPostCmds = collectHookCommands(codexHooks.PostToolUse);
         const codexStopCmds = collectHookCommands(codexHooks.Stop);
         const codexWiringOk = codexSessionCmds.some((cmd) => cmd.includes("session-start.sh")) &&
+            codexUserPromptCmds.some((cmd) => cmd.includes("prompt-guard.sh")) &&
+            codexUserPromptCmds.some((cmd) => cmd.includes("verify-current-state --quiet")) &&
             codexPreCmds.some((cmd) => cmd.includes("prompt-guard.sh")) &&
             codexPreCmds.some((cmd) => cmd.includes("workflow-guard.sh")) &&
             codexPostCmds.some((cmd) => cmd.includes("context-monitor.sh")) &&
@@ -827,7 +832,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         checks.push({
             name: "hook:wiring:codex",
             ok: codexWiringOk,
-            details: `${codexHooksFile} must wire session-start/prompt-guard/workflow-guard/context-monitor/stop-checkpoint (PreToolUse/PostToolUse run Bash-only in Codex v0.114+)`
+            details: `${codexHooksFile} must wire SessionStart, UserPromptSubmit(prompt-guard + verify-current-state), PreToolUse(prompt/workflow), PostToolUse(context-monitor), and Stop(stop-checkpoint). PreToolUse/PostToolUse run Bash-only in Codex v0.114+`
         });
         // Feature flag warning: Codex ignores `.codex/hooks.json` unless the
         // user has `[features] codex_hooks = true` in `~/.codex/config.toml`.
@@ -895,6 +900,8 @@ export async function doctorChecks(projectRoot, options = {}) {
     if (configuredHarnesses.includes("opencode")) {
         const file = path.join(projectRoot, ".opencode/plugins/cclaw-plugin.mjs");
         let ok = false;
+        let singleHandlerPathOk = false;
+        let precompactHookOk = false;
         if (await exists(file)) {
             const content = await fs.readFile(file, "utf8");
             ok =
@@ -904,16 +911,36 @@ export async function doctorChecks(projectRoot, options = {}) {
                     content.includes("prompt-guard.sh") &&
                     content.includes("workflow-guard.sh") &&
                     content.includes("context-monitor.sh") &&
+                    content.includes("pre-compact.sh") &&
                     content.includes('"session.idle"') &&
                     content.includes('"session.resumed"') &&
+                    content.includes('"session.compacted"') &&
                     content.includes('"session.cleared"') &&
                     content.includes('"experimental.chat.system.transform"');
+            singleHandlerPathOk =
+                !content.includes('eventType === "tool.execute.before"') &&
+                    !content.includes('eventType === "tool.execute.after"') &&
+                    content.includes('"tool.execute.before": async') &&
+                    content.includes('"tool.execute.after": async');
+            precompactHookOk =
+                content.includes('eventType === "session.compacted"') &&
+                    content.includes('runHookScript("pre-compact.sh"');
         }
         checks.push({
             name: "lifecycle:opencode:rehydration_events",
             ok,
             details: `${file} must include event lifecycle handler, tool.execute.before/after with prompt/workflow/context hooks, session.idle checkpoint, and transform rehydration`
         });
+        checks.push({
+            name: "hook:opencode:single_tool_handler_path",
+            ok: singleHandlerPathOk,
+            details: `${file} must route tool.execute.before/after through dedicated handlers exactly once (no duplicate event() branches).`
+        });
+        checks.push({
+            name: "hook:opencode:precompact_digest",
+            ok: precompactHookOk,
+            details: `${file} must run pre-compact.sh on session.compacted before bootstrap refresh.`
+        });
         const runtimeShape = await opencodePluginRuntimeShapeCheck(projectRoot);
         checks.push({
             name: "hook:opencode:runtime_shape",

package/dist/flow-state.js

@@ -59,10 +59,10 @@ export function createInitialFlowState(activeRunIdOrOptions = "active", maybeTra
     const track = options.track ?? "standard";
     const skippedStages = skippedStagesForTrack(track);
     const stageGateCatalog = {};
-    for (const schema of orderedStageSchemas()) {
+    for (const schema of orderedStageSchemas(track)) {
         stageGateCatalog[schema.stage] = {
-            required: stageGateIds(schema.stage),
-            recommended: stageRecommendedGateIds(schema.stage),
+            required: stageGateIds(schema.stage, track),
+            recommended: stageRecommendedGateIds(schema.stage, track),
             conditional: [],
             triggered: [],
             passed: [],

package/dist/gate-evidence.js

@@ -5,8 +5,8 @@ import { RUNTIME_ROOT } from "./constants.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { exists } from "./fs-utils.js";
 import { readFlowState, writeFlowState } from "./runs.js";
-async function currentStageArtifactExists(projectRoot, stage) {
-    const artifactFile = stageSchema(stage).artifactFile;
+async function currentStageArtifactExists(projectRoot, stage, track) {
+    const artifactFile = stageSchema(stage, track).artifactFile;
     const candidates = [
         path.join(projectRoot, RUNTIME_ROOT, "artifacts", artifactFile),
         path.join(projectRoot, artifactFile)
@@ -34,7 +34,7 @@ function sameStringArray(a, b) {
 }
 export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
     const stage = flowState.currentStage;
-    const schema = stageSchema(stage);
+    const schema = stageSchema(stage, flowState.track);
     const catalog = flowState.stageGateCatalog[stage];
     const required = schema.requiredGates
         .filter((gate) => gate.tier === "required")
@@ -92,7 +92,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState) {
             issues.push(`blocked gate "${gateId}" is not defined for stage "${stage}".`);
         }
     }
-    const artifactPresent = await currentStageArtifactExists(projectRoot, stage);
+    const artifactPresent = await currentStageArtifactExists(projectRoot, stage, flowState.track);
     const shouldValidateArtifact = artifactPresent || catalog.passed.length > 0 || flowState.completedStages.includes(stage);
     if (shouldValidateArtifact) {
         const lint = await lintArtifact(projectRoot, stage);
@@ -149,7 +149,7 @@ export function verifyCompletedStagesGateClosure(flowState) {
     const issues = [];
     const openStages = [];
     for (const stage of flowState.completedStages) {
-        const schema = stageSchema(stage);
+        const schema = stageSchema(stage, flowState.track);
         const catalog = flowState.stageGateCatalog[stage];
         const required = schema.requiredGates
             .filter((gate) => gate.tier === "required")
@@ -177,10 +177,11 @@ export function verifyCompletedStagesGateClosure(flowState) {
 }
 export function reconcileCurrentStageGateCatalog(flowState) {
     const stage = flowState.currentStage;
-    const required = stageSchema(stage).requiredGates
+    const schema = stageSchema(stage, flowState.track);
+    const required = schema.requiredGates
         .filter((gate) => gate.tier === "required")
         .map((gate) => gate.id);
-    const recommended = stageSchema(stage).requiredGates
+    const recommended = schema.requiredGates
         .filter((gate) => gate.tier === "recommended")
         .map((gate) => gate.id);
     const conditional = [];

package/dist/hook-schemas/codex-hooks.v1.json

@@ -5,6 +5,7 @@
     "schemaVersion": 1,
     "requiredEvents": [
         "SessionStart",
+        "UserPromptSubmit",
         "PreToolUse",
         "PostToolUse",
         "Stop"

package/dist/install.js

@@ -213,9 +213,10 @@ async function writeEvalScaffold(projectRoot) {
     }
 }
 async function writeSkills(projectRoot, config) {
+    const skillTrack = config?.defaultTrack ?? "standard";
     for (const stage of COMMAND_FILE_ORDER) {
         const folder = stageSkillFolder(stage);
-        await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), stageSkillMarkdown(stage));
+        await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), stageSkillMarkdown(stage, skillTrack));
         // Progressive disclosure (A.2#8): materialize the full example artifact as
         // a sibling reference file. The stage skill only links to it; agents load
         // the reference on demand.

package/dist/internal/advance-stage.js

@@ -354,7 +354,7 @@ async function runAdvanceStage(projectRoot, args, io) {
         io.stderr.write(`cclaw internal advance-stage: current stage is "${flowState.currentStage}", not "${args.stage}".\n`);
         return 1;
     }
-    const schema = stageSchema(args.stage);
+    const schema = stageSchema(args.stage, flowState.track);
     const requiredGateIds = schema.requiredGates
         .filter((gate) => gate.tier === "required")
         .map((gate) => gate.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.46.10",
+  "version": "0.46.11",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {