cclaw-cli 0.51.24 → 0.51.25

package/dist/content/examples.js

@@ -490,7 +490,7 @@ const GOOD_BAD_EXAMPLES = {
         },
         {
             label: "Scope change trace",
-            good: "Scope delta at 2026-04-15: user asked to add per-user mute preferences. Decision: moved from Out-of-scope → In-scope; acknowledged cost (≈1 day, +1 schema migration); risk: touches settings surface. Recorded in \`03-design.md#scope-trace\`. Requires re-running scope review before design lock.",
+            good: "Scope delta at 2026-04-15: user asked to add per-user mute preferences. Decision: moved from Out-of-scope → In-scope; acknowledged cost (≈1 day, +1 schema migration); risk: touches settings surface. Recorded in \`.cclaw/artifacts/03-design-<slug>.md#scope-trace\`. Requires re-running scope review before design lock.",
             bad: "Added mute preferences to scope.",
             lesson: "Scope changes silently are how projects drift. Every in↔out move needs a timestamp, a cost estimate, and a link to the next review it invalidates."
         }
@@ -676,12 +676,13 @@ function exampleSummaryBullets(stage) {
 const STAGE_EXAMPLE_SECTION_HEADINGS = {
     brainstorm: [
         "Problem Decision Record (product or technical-maintenance framing)",
-        "Candidate approaches with trade-offs",
+        "Reference Pattern Candidates and approaches with trade-offs",
         "Recommended direction + open questions",
         "Clarification log and decision record"
     ],
     scope: [
         "In-scope / out-of-scope / deferred lists with concrete capabilities",
+        "Reference Pattern Registry with accepted/rejected/deferred dispositions",
         "Requirements table with stable R# IDs",
         "Boundary stress-tests and non-negotiables",
         "Decision record for premise challenges"
@@ -689,6 +690,7 @@ const STAGE_EXAMPLE_SECTION_HEADINGS = {
     design: [
         "Blast-radius file list",
         "Mandatory architecture diagram (Mermaid)",
+        "Reference-Grade Contracts for mirrored patterns",
         "Failure-mode table with detection + mitigation",
         "Test strategy + performance budget",
         "Completion dashboard + unresolved decisions"
@@ -706,7 +708,7 @@ const STAGE_EXAMPLE_SECTION_HEADINGS = {
         "No-Placeholder scan row + WAIT_FOR_CONFIRM marker"
     ],
     tdd: [
-        "RED evidence per slice (failing test output)",
+        "RED evidence per vertical slice (failing test output)",
         "Acceptance mapping per slice",
         "GREEN evidence (full-suite pass)",
         "REFACTOR notes with behavior-preservation confirmation",
@@ -716,10 +718,11 @@ const STAGE_EXAMPLE_SECTION_HEADINGS = {
         "Spec-compliance findings (Layer 1)",
         "Code-quality findings (Layer 2)",
         "Severity, evidence, and status per finding",
-        "Go / no-go verdict"
+        "Victory Detector-backed go / no-go verdict"
     ],
     ship: [
         "Release checklist (version, changelog, tag, artifacts)",
+        "Victory Detector: valid review, fresh preflight, rollback, finalization enum",
         "Rollback plan with trigger, steps, verification",
         "Runbook (how to verify the release post-deploy)",
         "Sign-off block"
@@ -732,7 +735,7 @@ const DOMAIN_LABELS = {
     "data-pipeline": "Data pipeline / ETL"
 };
 export const RESEARCH_FLEET_USAGE_EXAMPLE = [
-    "Before drafting `03-design.md`, run `research/research-fleet.md` once and",
+    "Before drafting `.cclaw/artifacts/03-design-<slug>.md`, run `research/research-fleet.md` once and",
     "capture all four lenses in `.cclaw/artifacts/02a-research.md`.",
     "Dispatch semantics by harness: Claude/OpenCode/Codex = native subagents;",
     "Cursor = generic-dispatch Task mapping; role-switch only as degraded fallback.",

package/dist/content/next-command.js

@@ -76,7 +76,7 @@ ${conversationLanguagePolicyMarkdown()}
 
 1. Read **\`${flowPath}\`**. If missing → **BLOCKED** (state missing).
 2. Parse JSON. Capture \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, do not advance automatically. Re-run the stage artifact work, then clear the marker with \`cclaw internal rewind --ack <currentStage>\`.
+3. If \`staleStages[currentStage]\` exists, do not advance automatically. Report the stale marker reason/rewindId, re-run the stage artifact work, then clear only the current stage marker with \`cclaw internal rewind --ack <currentStage>\`.
 4. Read **\`${reconciliationNoticesPath}\`** when present. If it contains entries for \`activeRunId + currentStage\` and the listed gate is still blocked in \`stageGateCatalog[currentStage].blocked\`, emit a structured warning before any stage-advance decision.
 5. Let \`G\` = \`requiredGates\` for **\`currentStage\`** from the stage schema.
 6. Let \`catalog\` = \`stageGateCatalog[currentStage]\` from flow state.
@@ -85,7 +85,7 @@ ${conversationLanguagePolicyMarkdown()}
 9. If \`M\` is non-empty, inspect **\`${delegationPath}\`**. Treat as satisfied only if each mandatory agent is **completed** or **waived**.
 10. For each satisfied mandatory delegation row, verify \`evidenceRefs\` is a non-empty array (unless status is \`waived\` with rationale). Missing evidenceRefs means delegation is unresolved.
 11. If any mandatory delegation is missing and no waiver exists: **STOP** and ask the user whether to dispatch now or waive with rationale. Do not mark gates passed while delegation is unresolved.
-12. If \`currentStage === "review"\` and \`catalog.blocked\` includes \`review_criticals_resolved\`, treat this as a hard remediation branch: recommend \`cclaw internal rewind tdd "review_blocked_by_critical"\` with the blocking finding IDs, and do not attempt to advance toward ship.
+12. If \`currentStage === "review"\` and \`catalog.blocked\` includes \`review_criticals_resolved\`, treat this as a hard remediation branch: recommend the managed command \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\`, and do not attempt to advance toward ship. After TDD rework, require \`cclaw internal rewind --ack tdd\` before continuing.
 
 ### Path A: Current stage is NOT complete (any gate unmet or delegation missing)
 
@@ -186,11 +186,13 @@ ${conversationLanguagePolicyMarkdown()}
 Default output should be compact, like OMC/OMX operator surfaces:
 
 \`\`\`
-Stage: <currentStage> (<track>)
+Current: <currentStage or closeout.shipSubstate> (<track>)
+Stage: <currentStage>
 Gates: <passed>/<required> passed, <blocked> blocked
 Delegations: <done>/<mandatory> done
-Blockers: <none | gate/delegation/reconciliation ids>
+Blocked by: <none | gate/delegation/reconciliation/stale/TDD/review ids>
 Next: <exact next action, usually /cc-next or one named remediation>
+Evidence needed: <artifact/test/review/delegation evidence required to unblock>
 \`\`\`
 
 Only expand beyond this when blocked, when asking a structured question, or when
@@ -214,7 +216,7 @@ Do **not** mark gates satisfied from memory alone. Cite **artifact evidence** (p
 
 1. Open **\`${flowPath}\`**.
 2. Record \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, re-run the stage and clear marker via \`cclaw internal rewind --ack <currentStage>\` before advancing.
+3. If \`staleStages[currentStage]\` exists, show the marker reason/rewindId, re-run the stage, and clear only the current marker via \`cclaw internal rewind --ack <currentStage>\` before advancing.
 4. If the file is missing or invalid JSON → **BLOCKED** (report and stop).
 5. Read \`${reconciliationNoticesPath}\` when present. For entries matching \`activeRunId + currentStage\` whose gate is still in \`stageGateCatalog[currentStage].blocked\`, show a warning with gate id + reason before proceeding.
 
@@ -242,7 +244,9 @@ Execute the stage protocol. The stage skill handles interaction, STOP points, ga
 
 ${ralphLoopContractSnippet()}
 
-Special-case for review: if \`review_criticals_resolved\` is in \`blocked\`, route to rework instead of looping review forever — recommend \`cclaw internal rewind tdd "review_blocked_by_critical"\`.
+Special-case for review: if \`review_criticals_resolved\` is in \`blocked\`, route to rework instead of looping review forever - recommend \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\`, then \`cclaw internal rewind --ack tdd\` after TDD rework.
+
+Special-case for TDD blockers: when \`06-tdd.md\` records \`NO_SOURCE_CONTEXT\`, \`NO_TEST_SURFACE\`, \`NO_IMPLEMENTABLE_SLICE\`, \`RED_NOT_EXPRESSIBLE\`, or \`NO_VCS_MODE\`, keep status BLOCKED and print \`Current\`, \`Blocked by\`, \`Next\`, and \`Evidence needed\` instead of retrying speculative RED/GREEN work.
 
 **Path B — stage IS complete (all gates met, all delegations done):**
 

package/dist/content/reference-patterns.d.ts

@@ -0,0 +1,18 @@
+import type { FlowStage } from "../types.js";
+export interface ReferencePatternContract {
+    stage: FlowStage;
+    guidance: string[];
+    artifactSections: string[];
+}
+export interface ReferencePattern {
+    id: string;
+    title: string;
+    intent: string;
+    useWhen: string;
+    policyNeedles: string[];
+    contracts: ReferencePatternContract[];
+}
+export declare const REFERENCE_PATTERNS: ReferencePattern[];
+export declare function referencePatternsForStage(stage: FlowStage): ReferencePattern[];
+export declare function referencePatternContractsForStage(stage: FlowStage): ReferencePatternContract[];
+export declare function referencePatternPolicyNeedles(stage: FlowStage): string[];

package/dist/content/reference-patterns.js

@@ -0,0 +1,391 @@
+export const REFERENCE_PATTERNS = [
+    {
+        id: "socraticode_context_readiness",
+        title: "Context Readiness",
+        intent: "Do not draft from memory. Start once the agent can name upstream artifacts, discovered code patterns, template shape, and open blockers.",
+        useWhen: "Every stage before writing or validating an artifact.",
+        policyNeedles: ["Context Readiness", "upstream freshness", "template shape"],
+        contracts: [
+            {
+                stage: "brainstorm",
+                guidance: [
+                    "Capture discovered project context before asking approval questions.",
+                    "Separate observed facts from assumptions and open blockers."
+                ],
+                artifactSections: ["Context", "Discovered context"]
+            },
+            {
+                stage: "scope",
+                guidance: [
+                    "Name which brainstorm decisions are fresh enough to carry forward.",
+                    "If upstream decisions are stale or missing, stop for re-scope instead of inventing boundaries."
+                ],
+                artifactSections: ["Upstream Handoff", "Scope Contract"]
+            },
+            {
+                stage: "design",
+                guidance: [
+                    "Read blast-radius code before locking architecture.",
+                    "Use reference patterns as examples to adapt, not authority to copy."
+                ],
+                artifactSections: ["Codebase Investigation", "Reference-Grade Contracts"]
+            },
+            {
+                stage: "tdd",
+                guidance: [
+                    "Discover tests and affected contracts before opening a RED vertical slice.",
+                    "Map the slice to the active source item before editing production code."
+                ],
+                artifactSections: ["Test Discovery", "System-Wide Impact Check", "Acceptance Mapping"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Review only after current diff, test evidence, and source-item coverage are known.",
+                    "A no-finding verdict still needs inspected-surface evidence."
+                ],
+                artifactSections: ["Review Evidence Scope", "Completeness Snapshot"]
+            },
+            {
+                stage: "ship",
+                guidance: [
+                    "Ship only after fresh preflight, rollback trigger, and finalization mode are explicit.",
+                    "Treat stale review or missing rollback evidence as a blocker, not a concern."
+                ],
+                artifactSections: ["Preflight Results", "Rollback Plan", "Finalization"]
+            }
+        ]
+    },
+    {
+        id: "addy_reference_grade_contracts",
+        title: "Reference-Grade Contracts",
+        intent: "Promote good examples into explicit contracts: source, invariant, adaptation, rejection boundary, and verification signal.",
+        useWhen: "Brainstorm, scope, and design need reusable patterns without copying unrelated behavior.",
+        policyNeedles: ["Reference Pattern Registry", "Reference-Grade Contracts", "accepted/rejected reference ideas"],
+        contracts: [
+            {
+                stage: "brainstorm",
+                guidance: [
+                    "Record which reference patterns informed each option and which were rejected.",
+                    "A challenger must name the reference idea that makes it meaningfully higher-upside."
+                ],
+                artifactSections: ["Reference Pattern Candidates", "Approaches"]
+            },
+            {
+                stage: "scope",
+                guidance: [
+                    "Lock accepted, rejected, and deferred reference ideas as scope boundaries.",
+                    "Do not let a reference expand scope unless the user explicitly opts in."
+                ],
+                artifactSections: ["Reference Pattern Registry", "Scope Contract"]
+            },
+            {
+                stage: "design",
+                guidance: [
+                    "For every mirrored pattern, name source, invariant, adaptation, and verification evidence.",
+                    "If a reference conflicts with local architecture, reject it and document the revival signal."
+                ],
+                artifactSections: ["Reference-Grade Contracts", "Patterns to Mirror", "Rejected Alternatives"]
+            }
+        ]
+    },
+    {
+        id: "evanflow_coder_overseer",
+        title: "Coder / Overseer Split",
+        intent: "Keep implementation and validation context isolated: coders edit bounded slices, overseers read only, and integration overseers validate shared touchpoints.",
+        useWhen: "TDD, review, and parallel worker orchestration need safe independent implementation with fresh verification.",
+        policyNeedles: ["coder/overseer", "integration overseer", "non-overlap checks"],
+        contracts: [
+            {
+                stage: "plan",
+                guidance: [
+                    "Executable packets name file ownership, shared interfaces, expected failing test, passing command, and stop conditions.",
+                    "Parallel writers are allowed only after non-overlap checks for files, shared interfaces, migrations/config, and baseline cleanliness."
+                ],
+                artifactSections: ["Task List", "Dependency Batches", "Execution Posture"]
+            },
+            {
+                stage: "tdd",
+                guidance: [
+                    "Coder edits only the assigned slice after RED evidence; read-only overseer validates spec fit and assertion quality.",
+                    "When 3+ independent packets run, use an integration overseer for named touchpoints and integration tests."
+                ],
+                artifactSections: ["Execution Posture", "Per-Slice Review", "Verification Ladder"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Layered reviewers reconcile findings by source tag, confidence, owner, and verification requirement.",
+                    "Do not accept implementer self-review as overseer evidence."
+                ],
+                artifactSections: ["Review Evidence Scope", "Review Findings Contract"]
+            }
+        ]
+    },
+    {
+        id: "superpowers_executable_packet",
+        title: "Executable Packet",
+        intent: "Plan tasks as self-contained packets with acceptance mapping, expected RED failure, GREEN command, allowed files, and stop conditions.",
+        useWhen: "Plan and TDD need work items a fresh agent can execute without hidden parent context.",
+        policyNeedles: ["executable packet", "expected failing test", "stop condition"],
+        contracts: [
+            {
+                stage: "plan",
+                guidance: [
+                    "Each task is copy-paste ready for a worker and includes acceptance criteria, file boundaries, expected failing test, passing command, and stop conditions.",
+                    "Tasks that depend on shared interfaces or migration/config files are serialized unless an integration contract exists."
+                ],
+                artifactSections: ["Task List", "Dependency Batches", "Execution Posture"]
+            },
+            {
+                stage: "tdd",
+                guidance: [
+                    "Open one packet as one vertical slice; do not mix unrelated packet evidence.",
+                    "Close packet only when RED, GREEN, REFACTOR, and verification evidence align."
+                ],
+                artifactSections: ["Acceptance Mapping", "RED Evidence", "GREEN Evidence", "REFACTOR Notes"]
+            }
+        ]
+    },
+    {
+        id: "gstack_question_tuning",
+        title: "Question Tuning",
+        intent: "Ask only decision-changing questions, auto-assume low-risk two-way doors, and stop on one-way-door decisions.",
+        useWhen: "Brainstorm/scope/spec interactions could drift into broad interrogation instead of useful approval gates.",
+        policyNeedles: ["one decision-changing question", "two-way door", "one-way door"],
+        contracts: [
+            {
+                stage: "brainstorm",
+                guidance: [
+                    "Ask one decision-changing question at a time and record impact only when it changes direction or blocks progress.",
+                    "Continue on low-risk defaults; stop on scope, architecture, security, data loss, public API, migration, auth/pricing, or approval uncertainty."
+                ],
+                artifactSections: ["Sharpening Questions", "Selected Direction"]
+            },
+            {
+                stage: "scope",
+                guidance: [
+                    "Present labeled scope moves with one recommendation; wait for user opt-in before treating a mode as selected.",
+                    "Record what signal would change the recommendation."
+                ],
+                artifactSections: ["Scope Mode", "Scope Contract"]
+            },
+            {
+                stage: "spec",
+                guidance: [
+                    "Chunk acceptance criteria for approval and stop on assumptions with irreversible impact.",
+                    "Rewrite vague criteria before asking the user to approve."
+                ],
+                artifactSections: ["Acceptance Criteria", "Assumptions Before Finalization", "Approval"]
+            }
+        ]
+    },
+    {
+        id: "evanflow_vertical_slice_tdd",
+        title: "Vertical-Slice TDD",
+        intent: "Execute behavior end-to-end in one reviewable slice instead of collecting unrelated test or implementation fragments.",
+        useWhen: "TDD and review need to prove a source item moved from RED to GREEN with traceable behavior evidence.",
+        policyNeedles: ["vertical slice", "RED vertical slice", "slice victory detector"],
+        contracts: [
+            {
+                stage: "tdd",
+                guidance: [
+                    "One vertical slice is one source item plus one or more ACs, tests, implementation, refactor notes, and verification evidence.",
+                    "Do not open a second vertical slice while RED evidence or regression repair remains open for the current slice."
+                ],
+                artifactSections: ["Execution Posture", "RED Evidence", "GREEN Evidence", "Verification Ladder"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Review source-item coverage by vertical slice, not by file count alone.",
+                    "A slice is review-ready only when RED, GREEN, REFACTOR, and verification evidence all line up."
+                ],
+                artifactSections: ["Completeness Snapshot", "Trace Matrix Check"]
+            }
+        ]
+    },
+    {
+        id: "superclaude_confidence_gates",
+        title: "Confidence Gates",
+        intent: "Require source verification before execution and a fresh self-check before completion claims.",
+        useWhen: "Stage work could proceed from memory, duplicate an existing implementation, or close with stale evidence.",
+        policyNeedles: ["pre-execution confidence", "post-implementation self-check", "source verification"],
+        contracts: [
+            {
+                stage: "design",
+                guidance: [
+                    "Before locking architecture, verify duplicate implementation risk, architecture fit, docs/source truth, and root-cause confidence.",
+                    "If confidence is low, stop for investigation instead of adding fallback layers."
+                ],
+                artifactSections: ["Codebase Investigation", "Architecture Confidence"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Review requirements met, assumptions verified, tests passing, and evidence freshness before any PASS verdict.",
+                    "Separate verified facts from implementer claims."
+                ],
+                artifactSections: ["Review Readiness Snapshot", "Final Verdict"]
+            }
+        ]
+    },
+    {
+        id: "oh_my_worker_lifecycle",
+        title: "Worker Lifecycle Evidence",
+        intent: "Make asynchronous or delegated work inspectable through state, dispatch, evidence refs, and stale-worker handling.",
+        useWhen: "Stages schedule subagents, role-switch work, or generic dispatch and need auditable completion evidence.",
+        policyNeedles: ["dispatch lifecycle", "stale worker", "strict worker JSON schema"],
+        contracts: [
+            {
+                stage: "plan",
+                guidance: [
+                    "Plan only bounded worker packets with clear file ownership, stop conditions, and evidence expectations.",
+                    "Name any dispatch or concurrency governor before workers start."
+                ],
+                artifactSections: ["Task List", "Dependency Batches", "Execution Posture"]
+            },
+            {
+                stage: "tdd",
+                guidance: [
+                    "Every scheduled worker needs a terminal return with evidence refs or an explicit blocker route.",
+                    "A stale worker blocks completion until resolved, failed, or structurally waived."
+                ],
+                artifactSections: ["Execution Posture", "Verification Ladder", "Per-Slice Review"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Synthesize reviewer returns by status, source tag, evidence refs, and unresolved blockers.",
+                    "Do not treat missing worker output as a clean review."
+                ],
+                artifactSections: ["Review Evidence Scope", "Review Findings Contract"]
+            }
+        ]
+    },
+    {
+        id: "gsd_hard_stop_routing",
+        title: "Hard-Stop Routing",
+        intent: "Advance only when unresolved checkpoints, stale handoffs, and verification debt are cleared or routed explicitly.",
+        useWhen: "A stage wants to continue despite missing gates, stale rewind markers, or uncertain next command state.",
+        policyNeedles: ["hard-stop next routing", "goal-backward verification", "operator line"],
+        contracts: [
+            {
+                stage: "tdd",
+                guidance: [
+                    "Start from the outcome that must be true, then verify source, tests, artifact wiring, and gate evidence from that goal backward.",
+                    "If source/test preflight blocks execution, route to the managed blocker taxonomy instead of fabricating RED evidence."
+                ],
+                artifactSections: ["TDD Blocker Taxonomy", "Verification Ladder"]
+            },
+            {
+                stage: "ship",
+                guidance: [
+                    "Block ship on unresolved checkpoints, stale handoffs, or verification debt.",
+                    "Report the compact operator line: stage, scope, validation issues, recovery state, and next action."
+                ],
+                artifactSections: ["Preflight Results", "Completion Status", "Handoff"]
+            }
+        ]
+    },
+    {
+        id: "everyinc_delegation_preflight",
+        title: "Delegation Preflight",
+        intent: "Use delegation only when support, consent, baseline, non-overlap, batch size, and fallback mode are known.",
+        useWhen: "A controller is about to fan out implementation or review work across multiple specialists.",
+        policyNeedles: ["delegation preflight", "non-overlapping files", "layered review synthesis"],
+        contracts: [
+            {
+                stage: "plan",
+                guidance: [
+                    "Before parallel writers, verify support, user consent when needed, baseline cleanliness, non-overlapping files, batch size, and fallback mode.",
+                    "Shared interfaces, migrations, config, and generated surfaces need an integration contract or serial execution."
+                ],
+                artifactSections: ["Dependency Batches", "Execution Posture"]
+            },
+            {
+                stage: "review",
+                guidance: [
+                    "Dedupe layered reviewer findings with confidence, owner, and verification requirement.",
+                    "Keep user-facing synthesis separate from raw worker returns."
+                ],
+                artifactSections: ["Layered Review Synthesis", "Review Findings Contract"]
+            }
+        ]
+    },
+    {
+        id: "ecc_worktree_control_plane",
+        title: "Worktree Control Plane",
+        intent: "Treat isolated worker state, handoff files, and orchestration snapshots as recoverable control-plane data rather than chat memory.",
+        useWhen: "Parallel or resumable work needs clear seed paths, state files, handoffs, and cleanup visibility.",
+        policyNeedles: ["worktree control plane", "handoff files", "orchestration snapshot"],
+        contracts: [
+            {
+                stage: "plan",
+                guidance: [
+                    "Name seed paths, worker handoff expectations, and integration touchpoints before isolated work begins.",
+                    "Cap ad-hoc teams and require agreement/conflict synthesis for any multi-agent result."
+                ],
+                artifactSections: ["Task List", "Dependency Batches", "Execution Posture"]
+            },
+            {
+                stage: "ship",
+                guidance: [
+                    "Confirm handoffs, cleanup, and orchestration state are captured before archive or closeout.",
+                    "Do not rely on chat transcript alone for recoverability."
+                ],
+                artifactSections: ["Handoff", "Completion Status"]
+            }
+        ]
+    },
+    {
+        id: "walkinglabs_victory_detector",
+        title: "Iterate / Victory Detector",
+        intent: "Iterate while evidence is missing; stop only when the stage-specific victory detector is satisfied or a real blocker is named.",
+        useWhen: "Content-only closeout wording for review and ship readiness.",
+        policyNeedles: ["Victory Detector", "iterate until evidence", "fresh evidence"],
+        contracts: [
+            {
+                stage: "review",
+                guidance: [
+                    "Victory Detector: Layer 1, Layer 2, security sweep, structured findings, and trace evidence are complete with no unresolved criticals unless verdict is BLOCKED.",
+                    "If the detector fails, iterate findings or route back to TDD; do not say LGTM."
+                ],
+                artifactSections: ["Review Readiness Snapshot", "Final Verdict"]
+            },
+            {
+                stage: "ship",
+                guidance: [
+                    "Victory Detector: valid review verdict, fresh preflight, rollback trigger/steps, selected finalization enum, and execution result are present.",
+                    "If any detector field is stale or missing, keep status BLOCKED."
+                ],
+                artifactSections: ["Preflight Results", "Rollback Plan", "Finalization", "Completion Status"]
+            }
+        ]
+    }
+];
+export function referencePatternsForStage(stage) {
+    return REFERENCE_PATTERNS.filter((pattern) => pattern.contracts.some((contract) => contract.stage === stage));
+}
+export function referencePatternContractsForStage(stage) {
+    return REFERENCE_PATTERNS.flatMap((pattern) => pattern.contracts
+        .filter((contract) => contract.stage === stage)
+        .map((contract) => ({
+        ...contract,
+        guidance: [...contract.guidance],
+        artifactSections: [...contract.artifactSections]
+    })));
+}
+export function referencePatternPolicyNeedles(stage) {
+    const needles = [];
+    const seen = new Set();
+    for (const pattern of referencePatternsForStage(stage)) {
+        for (const needle of pattern.policyNeedles) {
+            if (seen.has(needle))
+                continue;
+            seen.add(needle);
+            needles.push(needle);
+        }
+    }
+    return needles;
+}