cclaw-cli 0.51.30 → 1.0.0

package/dist/content/skills.js

@@ -3,10 +3,10 @@ import { nextStage as nextStageForTrack } from "../flow-state.js";
 import { FLOW_STAGES } from "../types.js";
 import { stageExamples } from "./examples.js";
 import { reviewStackAwareRoutes, reviewStackAwareRoutingSummary, stageAutoSubagentDispatch, stageSchema, stageTrackRenderContext } from "./stage-schema.js";
-import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
 import { referencePatternsForStage } from "./reference-patterns.js";
 import { harnessDelegationRecipes } from "../harness-adapters.js";
 const VERIFICATION_STAGES = ["tdd", "review", "ship"];
+const STAGE_LANGUAGE_POLICY_POINTER = "> Language policy: see `using-cclaw` section `Conversation Language Policy`.";
 // ---------- Cross-cutting universal mechanics (Layer 2 building blocks) ----------
 //
 // These are shared, structural blocks that get injected into every stage skill.
@@ -363,7 +363,7 @@ function completionParametersBlock(schema, track) {
     const nextDescription = nextStage === "done"
         ? "flow complete"
         : stageSchema(nextStage, track).skillDescription;
-    return `## Completion Parameters
+    return `### Completion Parameters
 
 - \`stage\`: \`${schema.stage}\`
 - \`next\`: \`${nextStage}\` (${nextDescription})
@@ -373,13 +373,26 @@ function completionParametersBlock(schema, track) {
 - \`completion helper\`: \`node .cclaw/hooks/stage-complete.mjs ${schema.stage}\`
 - \`completion helper with evidence\`: \`node .cclaw/hooks/stage-complete.mjs ${schema.stage} --evidence-json '{"<gate_id>":"<evidence note>"}' --passed=<gate_id>[,<gate_id>]\`
 - \`completion helper JSON diagnostics\`: append \`--json\` to receive a machine-readable validation failure summary.
-- \`delegation record helper\`: \`node .cclaw/hooks/delegation-record.mjs --stage=${schema.stage} --agent=<agent> --mode=<mandatory|proactive> --status=<scheduled|launched|acknowledged|completed|failed|waived|stale> --span-id=<spanId> --dispatch-id=<dispatchId> --dispatch-surface=<surface> --agent-definition-path=<path> --json\`. \`delegation helper recipe\`: call \`--status=scheduled\`, then \`--status=launched\`, then \`--status=acknowledged\`, then \`--status=completed\` with the same \`--span-id\`, \`--dispatch-id\`, \`--dispatch-surface\`, and \`--agent-definition-path\`; completed isolated/generic rows fail unless that same span already has an acknowledged event or the completed call includes \`--ack-ts=<iso>\`. For role-switch fallback, use \`--dispatch-surface=role-switch --evidence-ref=<artifact#anchor>\` instead of pretending isolated completion.
+- \`delegation lifecycle proof\`: use the delegation helper recipe in this section with explicit lifecycle rows: \`--status=scheduled\` -> \`--status=launched\` -> \`--status=acknowledged\` -> \`--status=completed\` (completed isolated/generic requires prior ACK for the same span or \`--ack-ts=<iso>\`).
 - Fill \`## Learnings\` before closeout: either \`- None this stage.\` or JSON bullets with required keys \`type\`, \`trigger\`, \`action\`, \`confidence\` (knowledge-schema compatible).
-- Record mandatory delegation lifecycle in \`${RUNTIME_ROOT}/state/delegation-log.json\` and append proof events to \`${RUNTIME_ROOT}/state/delegation-events.jsonl\`; the ledger is current state, the event log is audit proof.${mandatoryAgents.length > 0 ? ` If a mandatory delegation cannot run in this harness, use \`--waive-delegation=${mandatoryAgents.join(",")} --waiver-reason="<why safe>"\` on the completion helper.` : ""}
+- Record mandatory delegation lifecycle in \`${RUNTIME_ROOT}/state/delegation-log.json\` and append proof events to \`${RUNTIME_ROOT}/state/delegation-events.jsonl\`; the ledger is current state, the event log is audit proof.${mandatoryAgents.length > 0 ? ` If a mandatory delegation cannot run in this harness, use \`--waive-delegation=${mandatoryAgents.join(",")} --waiver-reason="<why safe>"\` on the completion helper.` : ""} If proactive delegations were intentionally skipped, rerun only with \`--accept-proactive-waiver\` (optionally \`--accept-proactive-waiver-reason="<why safe>"\`) after explicit user approval.
 - Never edit raw \`flow-state.json\` to complete a stage, even in advisory mode; that bypasses validation, gate evidence, and Learnings harvest. If the helper fails, stop and report the exact command/output instead of applying a manual state workaround.
 - Completion protocol: verify required gates, update the artifact, then use the completion helper with \`--evidence-json\` and \`--passed\` for every satisfied gate.
 `;
 }
+function delegationAndCompletionBlock(schema, track) {
+    const dispatchBlock = autoSubagentDispatchBlock(schema.stage, track).trim();
+    const completionBlock = completionParametersBlock(schema, track).trim();
+    const normalizedDispatch = dispatchBlock.length > 0
+        ? dispatchBlock.replace(/^## Automatic Subagent Dispatch/mu, "### Automatic Subagent Dispatch")
+        : "### Automatic Subagent Dispatch\nNo automatic subagent dispatch rules for this stage.";
+    return `## Delegation & Completion
+
+${normalizedDispatch}
+
+${completionBlock}
+`;
+}
 function quickStartBlock(stage, track) {
     const schema = stageSchema(stage, track);
     const gatePreview = schema.executionModel.requiredGates.slice(0, 3).map((g) => `\`${g.id}\``).join(", ");
@@ -516,7 +529,7 @@ If you are about to violate the Iron Law, STOP. No amount of urgency, partial pr
 
 ${quickStartBlock(stage, track)}
 
-${conversationLanguagePolicyMarkdown()}
+${STAGE_LANGUAGE_POLICY_POINTER}
 ## Philosophy
 ${philosophy.purpose}
 
@@ -541,7 +554,7 @@ Stage state machine (map only; Checklist is authoritative):
 ${processFlowMermaid.length > 0 ? processFlowMermaid : "```mermaid\nflowchart TD\n  S1[\"Execute Checklist\"] --> S2[\"Satisfy required gates\"] --> S3[\"Verify before closeout\"]\n```"}
 
 ${platformNotesBlock}${contextLoadingBlock(stage, artifactRules.crossStageTrace, executionModel)}
-${autoSubagentDispatchBlock(stage, track)}
+${delegationAndCompletionBlock(schema, track)}
 ${stackAwareReviewRoutingBlock(stage)}
 ${researchPlaybooksBlock(executionModel.researchPlaybooks ?? [])}
 ${referencePatternsBlock(stage)}
@@ -575,7 +588,6 @@ ${verificationBlock(stage)}
 ## Exit Criteria
 ${executionModel.exitCriteria.map((item) => `- [ ] ${item}`).join("\n")}
 
-${completionParametersBlock(schema, track)}
 ## Artifact Rules
 - Artifact target: \`${RUNTIME_ROOT}/artifacts/${artifactRules.artifactFile}\`
 
@@ -595,3 +607,53 @@ ${reviewSectionsBlock(reviewLens.reviewSections)}
 - Keep decisions explicit: context, options, chosen option, rationale, risk, and rollback.
 `;
 }
+export function executingWavesSkillMarkdown() {
+    return `---
+name: executing-waves
+description: "Execute multi-wave work using existing cclaw run resume + verify-current-state — no new CLI needed."
+---
+
+# Executing Waves (Persistent Multi-Wave Work)
+
+## Overview
+
+Long-form work (large refactors, multi-stage uplifts) often spans many waves.
+This skill documents how the controller persists work across waves WITHOUT new
+CLI commands, using existing \`cclaw run resume\` and \`internal verify-current-state\`.
+
+## When to Use
+
+- Work spans 2+ commits / waves with cohesion concerns between waves.
+- Each wave has its own stage cycle (brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship).
+- User wants explicit per-wave verification before the next wave starts.
+- Risk of cross-wave drift exists.
+
+## Anti-Pattern
+
+- Running many waves linearly without verification between them, accumulating drift.
+- Treating a wave as only a commit boundary without re-verifying upstream decisions.
+
+## Process
+
+1. **Wave Start**: author wave plan as \`.cclaw/wave-plans/<wave-n>.md\` referencing previous wave's ship artifact.
+2. **Carry-forward Audit**: at brainstorm of the next wave, re-read previous wave ship artifact and explicitly record:
+   - Carrying forward: <locked decisions still valid>
+   - Drift detected: <decisions no longer valid + reason>
+   - Re-scope needed: <yes/no>
+3. **Resume Path**: if a wave was interrupted mid-stage, \`cclaw run resume\` restores state. Run \`internal verify-current-state\` before continuing.
+4. **Wave End**: at ship, architect cross-stage verification runs from dispatch matrix. If \`DRIFT_DETECTED\`, fix before ship.
+5. **Next Wave Trigger**: launch new \`/cc <topic>\` for next wave and reference previous wave ship artifact in upstream handoff.
+
+## Status Markers
+
+- \`wave-status: in-progress\` — current stage incomplete.
+- \`wave-status: blocked-by-prev\` — waiting on previous wave verification.
+- \`wave-status: shipped\` — wave shipped, next wave can start.
+- \`wave-status: rolled-back\` — previous wave invalidated, current wave needs rebase.
+
+## Linter Hooks
+
+- If multi-wave work is detected (>1 wave-plan files in \`.cclaw/wave-plans/\`), current brainstorm artifact MUST contain \`## Wave Carry-forward\` section with drift audit.
+- If carry-forward drift is missing in multi-wave context, emit \`[P1] wave.drift_unaddressed\`.
+`;
+}

package/dist/content/stage-schema.js

@@ -89,23 +89,24 @@ function defaultReturnSchemaForAgent(agent) {
             return "architecture-return";
         case "spec-validator":
             return "spec-validation-return";
+        case "spec-document-reviewer":
+        case "coherence-reviewer":
+        case "scope-guardian-reviewer":
+        case "feasibility-reviewer":
+            return "review-return";
         case "slice-implementer":
             return "worker-return";
-        case "performance-reviewer":
-            return "performance-return";
-        case "compatibility-reviewer":
-            return "compatibility-return";
-        case "observability-reviewer":
-            return "observability-return";
         case "release-reviewer":
             return "release-return";
         case "planner":
             return "planning-return";
-        case "product-manager":
+        case "product-discovery":
             return "product-return";
+        case "divergent-thinker":
         case "critic":
             return "critic-return";
         case "reviewer":
+        case "integration-overseer":
             return "review-return";
         case "security-reviewer":
             return "security-return";
@@ -115,14 +116,12 @@ function defaultReturnSchemaForAgent(agent) {
             return "docs-return";
         case "fixer":
             return "fixer-return";
-        case "implementer":
-            return "worker-return";
     }
 }
 function dispatchClassForRow(row) {
     if (row.dispatchClass)
         return row.dispatchClass;
-    if (row.agent === "implementer" || row.agent === "fixer" || row.agent === "slice-implementer")
+    if (row.agent === "fixer" || row.agent === "slice-implementer")
         return "worker";
     return row.skill?.includes("review") || row.agent === "reviewer" || row.agent === "security-reviewer" || row.agent.endsWith("-reviewer")
         ? "review-lens"
@@ -258,6 +257,7 @@ const REQUIRED_GATE_IDS = {
     design: [
         "design_research_complete",
         "design_architecture_locked",
+        "design_diagram_freshness",
         "design_data_flow_mapped",
         "design_failure_modes_mapped",
         "design_test_and_perf_defined"
@@ -266,6 +266,7 @@ const REQUIRED_GATE_IDS = {
         "spec_acceptance_measurable",
         "spec_testability_confirmed",
         "spec_assumptions_surfaced",
+        "spec_self_review_complete",
         "spec_user_approved"
     ],
     plan: [
@@ -282,6 +283,9 @@ const REQUIRED_GATE_IDS = {
         "tdd_green_full_suite",
         "tdd_refactor_completed",
         "tdd_verified_before_complete",
+        "tdd_iron_law_acknowledged",
+        "tdd_watched_red_observed",
+        "tdd_slice_cycle_complete",
         "tdd_docs_drift_check",
         ...(track === "quick" ? [] : ["tdd_traceable_to_plan"])
     ],
@@ -290,8 +294,7 @@ const REQUIRED_GATE_IDS = {
         "review_layer2_security",
         "review_layer_coverage_complete",
         "review_criticals_resolved",
-        "review_army_json_valid",
-        ...(track === "quick" ? [] : ["review_trace_matrix_clean"])
+        "review_army_json_valid"
     ],
     ship: [
         "ship_review_verdict_valid",
@@ -322,9 +325,27 @@ const REQUIRED_ARTIFACT_SECTIONS = {
         "Spec Handoff",
         "Completion Dashboard"
     ],
-    spec: ["Acceptance Criteria", "Edge Cases", "Assumptions Before Finalization", "Acceptance Mapping", "Approval"],
+    spec: [
+        "Acceptance Criteria",
+        "Edge Cases",
+        "Assumptions Before Finalization",
+        "Acceptance Mapping",
+        "Spec Self-Review",
+        "Approval"
+    ],
     plan: ["Task List", "Dependency Batches", "Acceptance Mapping", "Execution Posture", "WAIT_FOR_CONFIRM"],
-    tdd: ["Test Discovery", "System-Wide Impact Check", "RED Evidence", "GREEN Evidence", "REFACTOR Notes", "Traceability", "Verification Ladder"],
+    tdd: [
+        "Test Discovery",
+        "System-Wide Impact Check",
+        "RED Evidence",
+        "GREEN Evidence",
+        "REFACTOR Notes",
+        "Traceability",
+        "Iron Law Acknowledgement",
+        "Watched-RED Proof",
+        "Vertical Slice Cycle",
+        "Verification Ladder"
+    ],
     review: ["Review Evidence Scope", "Changed-File Coverage", "Layer 1 Verdict", "Review Findings Contract", "Severity Summary", "Final Verdict"],
     ship: ["Preflight Results", "Release Notes", "Rollback Plan", "Finalization"]
 };
@@ -421,11 +442,18 @@ const STAGE_SCHEMA_MAP = {
 const STAGE_AUTO_SUBAGENT_DISPATCH = {
     brainstorm: [
         {
-            agent: "product-manager",
+            agent: "product-discovery",
             mode: "mandatory",
             requiredAtTier: "standard",
             when: "Always for standard/deep brainstorm to validate value, persona/JTBD, success metric, and why-now framing.",
-            purpose: "Pressure-test problem/value fit and produce product-discovery evidence for the Problem Decision Record.",
+            purpose: "Run product-discovery mode to pressure-test problem/value fit and produce product evidence for the Problem Decision Record.",
+            requiresUserGate: false
+        },
+        {
+            agent: "divergent-thinker",
+            mode: "proactive",
+            when: "When brainstorm has >1 candidate direction or user signals openness to alternatives.",
+            purpose: "Expand option-space with alternative framings and approaches before planner/critic convergence.",
             requiresUserGate: false
         },
         {
@@ -433,8 +461,9 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             mode: "mandatory",
             requiredAtTier: "standard",
             when: "Always for standard/deep brainstorm to challenge the premise, do-nothing path, and higher-upside alternatives.",
-            purpose: "Attack assumptions and surface non-goals before direction approval.",
-            requiresUserGate: false
+            purpose: "Attack assumptions and surface non-goals before direction approval, with pre-commitment predictions validated against evidence.",
+            requiresUserGate: false,
+            skill: "critic-multi-perspective"
         },
         {
             agent: "researcher",
@@ -453,13 +482,21 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             purpose: "Challenge premise, map alternatives, and produce explicit in/out contract.",
             requiresUserGate: false
         },
+        {
+            agent: "divergent-thinker",
+            mode: "proactive",
+            when: "When scope mode is SCOPE EXPANSION or SELECTIVE EXPANSION, or scope contract has fewer than 3 alternatives considered.",
+            purpose: "Generate additional framings and approach variants before scope convergence hardens.",
+            requiresUserGate: false
+        },
         {
             agent: "critic",
             mode: "mandatory",
             requiredAtTier: "standard",
             when: "Always during scope shaping for standard/deep work.",
-            purpose: "Test whether the selected scope mode is too timid, too broad, or hiding a smaller useful slice.",
-            requiresUserGate: false
+            purpose: "Test whether the selected scope mode is too timid, too broad, or hiding a smaller useful slice, using pre-commitment predictions and validation.",
+            requiresUserGate: false,
+            skill: "critic-multi-perspective"
         },
         {
             agent: "researcher",
@@ -469,11 +506,27 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             requiresUserGate: false
         },
         {
-            agent: "product-manager",
+            agent: "product-discovery",
             mode: "proactive",
-            when: "When scope choices change user value, success metrics, or product positioning.",
-            purpose: "Keep accepted/deferred reference ideas tied to user value and measurable success.",
+            when: "When scope choices change user value, success metrics, or product positioning (Mode: discovery).",
+            purpose: "Keep accepted/deferred reference ideas tied to user value and measurable success under product-discovery mode.",
             requiresUserGate: false
+        },
+        {
+            agent: "product-discovery",
+            mode: "proactive",
+            requiredAtTier: "standard",
+            when: "When scope mode resolves to SCOPE EXPANSION or SELECTIVE EXPANSION (Mode: strategist).",
+            purpose: "Drive 10x vision and concrete expansion proposals before locking the scope contract via product-discovery strategist mode.",
+            requiresUserGate: false
+        },
+        {
+            agent: "scope-guardian-reviewer",
+            mode: "proactive",
+            when: "When scope mode is SCOPE EXPANSION or SELECTIVE EXPANSION, or scope contract has many accepted ideas.",
+            purpose: "Challenge complexity growth and enforce minimum-change scope discipline before scope lock.",
+            requiresUserGate: false,
+            skill: "document-scope-guard"
         }
     ],
     design: [
@@ -496,9 +549,10 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "critic",
             mode: "proactive",
-            when: "When architecture alternatives, coupling, cost, or rollback risk remain debatable.",
-            purpose: "Produce a shadow alternative, switch trigger, and cheaper-path challenge for the engineering lock.",
-            requiresUserGate: false
+            when: "When architecture alternatives, coupling, cost, or rollback risk remain debatable, or when security/auth/authz trust boundaries are involved.",
+            purpose: "Produce a shadow alternative, switch trigger, and cheaper-path challenge for the engineering lock with pre-commitment predictions and validation.",
+            requiresUserGate: false,
+            skill: "critic-multi-perspective"
         },
         {
             agent: "researcher",
@@ -515,20 +569,20 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             requiresUserGate: false
         },
         {
-            agent: "compatibility-reviewer",
+            agent: "coherence-reviewer",
             mode: "proactive",
-            requiredAtTier: "lightweight",
-            when: "When public API, config, persisted data, CLI, generated clients, or cross-version behavior can change.",
-            purpose: "Identify backward-compatibility and migration hazards before spec/plan.",
-            requiresUserGate: false
+            when: "When design touches multiple subsystems or includes multiple alternatives sections.",
+            purpose: "Detect internal contradictions, terminology drift, and broken cross-section references in design docs.",
+            requiresUserGate: false,
+            skill: "document-coherence-pass"
         },
         {
-            agent: "observability-reviewer",
+            agent: "feasibility-reviewer",
             mode: "proactive",
-            requiredAtTier: "lightweight",
-            when: "When runtime/debuggability, rollout, failure detection, or supportability matters.",
-            purpose: "Validate logs/metrics/traces, alerting, and rescue-path visibility before implementation.",
-            requiresUserGate: false
+            when: "When design assumes runtime conditions, scaling behavior, or external service availability.",
+            purpose: "Validate that design assumptions remain feasible in real runtime and rollout constraints.",
+            requiresUserGate: false,
+            skill: "document-feasibility-pass"
         }
     ],
     spec: [
@@ -546,6 +600,22 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             when: "When acceptance criteria need testability review or RED expressibility is uncertain.",
             purpose: "Confirm likely test levels, commands/manual evidence, and assertion surfaces are concrete.",
             requiresUserGate: false
+        },
+        {
+            agent: "spec-document-reviewer",
+            mode: "proactive",
+            requiredAtTier: "standard",
+            when: "When Spec Self-Review reports gaps (Status: Issues Found) or subsystem boundaries drift beyond one coherent plan slice.",
+            purpose: "Run a final document-level quality pass for completeness, consistency, clarity, and scope fit before handoff to plan.",
+            requiresUserGate: false
+        },
+        {
+            agent: "coherence-reviewer",
+            mode: "proactive",
+            when: "When spec has more than five acceptance criteria or multiple assumptions sections.",
+            purpose: "Check cross-section coherence, terminology consistency, and internal references before plan handoff.",
+            requiresUserGate: false,
+            skill: "document-coherence-pass"
         }
     ],
     plan: [
@@ -563,6 +633,30 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             when: "When plan tasks touch unfamiliar areas or reference-pattern adoption needs source verification.",
             purpose: "Confirm context/search evidence before plan packets rely on discovered patterns.",
             requiresUserGate: false
+        },
+        {
+            agent: "coherence-reviewer",
+            mode: "proactive",
+            when: "When plan packets touch more than one subsystem or map more than five dependency edges.",
+            purpose: "Verify internal consistency across batches, dependencies, and handoff narratives.",
+            requiresUserGate: false,
+            skill: "document-coherence-pass"
+        },
+        {
+            agent: "scope-guardian-reviewer",
+            mode: "proactive",
+            when: "When plan introduces new abstractions or generic utility layers.",
+            purpose: "Challenge unnecessary abstraction and enforce minimum viable implementation scope.",
+            requiresUserGate: false,
+            skill: "document-scope-guard"
+        },
+        {
+            agent: "feasibility-reviewer",
+            mode: "proactive",
+            when: "When plan carries runtime, environment, dependency, or resource assumptions.",
+            purpose: "Validate execution and rollout feasibility before implementation starts.",
+            requiresUserGate: false,
+            skill: "document-feasibility-pass"
         }
     ],
     tdd: [
@@ -583,6 +677,13 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             purpose: "Implement the minimal passing slice inside explicit file boundaries and return strict worker evidence.",
             requiresUserGate: false
         },
+        {
+            agent: "integration-overseer",
+            mode: "proactive",
+            when: "When TDD fan-out used 2+ parallel slice-implementers, or when slices touch shared interfaces.",
+            purpose: "Verify cohesion-contract integrity across shared types, touchpoints, invariants, and integration test outcomes after fan-in.",
+            requiresUserGate: false
+        },
         {
             agent: "reviewer",
             mode: "proactive",
@@ -604,7 +705,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             mode: "mandatory",
             requiredAtTier: "lightweight",
             when: "Always in review stage.",
-            purpose: "Layer 1 spec compliance plus integrated Layer 2 review across correctness, architecture, and external-safety tags with source-tagged findings.",
+            purpose: "Layer 1 spec compliance plus integrated Layer 2 review across correctness, architecture, and inline performance/compatibility/observability lens coverage with source-tagged findings. Escalate to optional dedicated lens skills only when diff scope/risk justifies a deeper pass.",
             requiresUserGate: false,
             skill: "review-spec-pass"
         },
@@ -617,30 +718,6 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
             requiresUserGate: false,
             skill: "security-audit"
         },
-        {
-            agent: "performance-reviewer",
-            mode: "proactive",
-            requiredAtTier: "lightweight",
-            when: "When hot paths, IO, data volume, rendering, caching, or algorithmic cost can move.",
-            purpose: "Run a focused performance lens and report evidence-backed regressions or no-impact rationale.",
-            requiresUserGate: false
-        },
-        {
-            agent: "compatibility-reviewer",
-            mode: "proactive",
-            requiredAtTier: "lightweight",
-            when: "When public API, CLI/config, persisted data, generated clients, or dependency versions change.",
-            purpose: "Check compatibility, migrations, and consumer-facing contract stability.",
-            requiresUserGate: false
-        },
-        {
-            agent: "observability-reviewer",
-            mode: "proactive",
-            requiredAtTier: "lightweight",
-            when: "When failure diagnosis, logging/metrics/traces, rollout, or operational support matters.",
-            purpose: "Check observability and supportability evidence against the design/review artifact.",
-            requiresUserGate: false
-        },
         {
             agent: "reviewer",
             mode: "proactive",
@@ -667,6 +744,15 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         }
     ],
     ship: [
+        {
+            agent: "architect",
+            mode: "mandatory",
+            requiredAtTier: "lightweight",
+            when: "Always before final ship — verify cross-stage cohesion across scope/design/spec/plan/code.",
+            purpose: "Final cross-stage cohesion gate before release finalization.",
+            requiresUserGate: false,
+            skill: "architect-cross-stage-verification"
+        },
         {
             agent: "release-reviewer",
             mode: "mandatory",

package/dist/content/stages/_lint-metadata/index.js

@@ -6,6 +6,9 @@ const STAGE_POLICY_NEEDLES = {
         "Explore project context",
         "One question at a time",
         "2-3 architecturally distinct approaches",
+        "Embedded Grill",
+        "Victory Detector",
+        "Critic Pass",
         "State what is being approved",
         "Self-review before handoff",
         "Do NOT implement, scaffold, or modify behavior"
@@ -17,7 +20,9 @@ const STAGE_POLICY_NEEDLES = {
         "Discretion Areas",
         "NOT in scope",
         "Premise Challenge",
-        "Locked Decisions"
+        "Locked Decisions",
+        "Victory Detector",
+        "Critic Pass"
     ],
     design: [
         "Parallel Research Fleet",
@@ -25,9 +30,21 @@ const STAGE_POLICY_NEEDLES = {
         "Data Flow",
         "Failure Modes and Mitigation",
         "Performance Budget",
+        "Long-Term Trajectory",
+        "Victory Detector",
+        "Critic Pass",
         "One issue at a time"
     ],
-    spec: ["Acceptance Criteria", "Constraints", "Assumptions Before Finalization", "Testability", "approved spec", "Edge Cases"],
+    spec: [
+        "Acceptance Criteria",
+        "Constraints",
+        "Assumptions Before Finalization",
+        "Testability",
+        "Spec Self-Review",
+        "single subsystem",
+        "approved spec",
+        "Edge Cases"
+    ],
     plan: [
         "WAIT_FOR_CONFIRM",
         "Task Graph",
@@ -35,6 +52,8 @@ const STAGE_POLICY_NEEDLES = {
         "Acceptance Mapping",
         "verification steps",
         "Execution Posture",
+        "Calibrated Findings",
+        "Regression Iron Rule",
         "Locked Decision Coverage"
     ],
     tdd: [
@@ -42,8 +61,13 @@ const STAGE_POLICY_NEEDLES = {
         "GREEN",
         "REFACTOR",
         "failing test",
+        "Iron Law Acknowledgement",
+        "Watched-RED Proof",
+        "Vertical Slice Cycle",
         "Test Discovery",
         "System-Wide Impact Check",
+        "TDD Blocker Taxonomy",
+        "Per-Slice Review",
         "full test suite",
         "acceptance criteria",
         "traceable to plan slice"

package/dist/content/stages/brainstorm.js

@@ -5,8 +5,8 @@ export const BRAINSTORM = {
     schemaShape: "v2",
     stage: "brainstorm",
     complexityTier: "standard",
-    skillFolder: "brainstorming",
-    skillName: "brainstorming",
+    skillFolder: "brainstorm",
+    skillName: "brainstorm",
     skillDescription: "Problem-discovery stage. Build a concise Problem Decision Record, choose lite/standard/deep depth, compare distinct directions, and hand approved decisions to scope.",
     philosophy: {
         hardGate: "Do NOT invoke implementation skills, write code, scaffold projects, or mutate product behavior until a concrete direction is approved by the user.",
@@ -43,15 +43,17 @@ export const BRAINSTORM = {
             "**Reframe with How Might We** — write a single `How Might We …?` line that names the user/operator, the desired outcome, and the constraint. This is the altitude check before approaches.",
             "**Run Clarity Gate** — record ambiguity score (0.00-1.00), decision boundaries, reaffirmed non-goals, and residual-risk handoff before locking recommendations. If ambiguity remains high (>0.40), ask one decision-changing question before recommending.",
             "**Sharpening question discipline** — ask one decision-changing question at a time. Do not default to 3-5 batched questions; record only questions that changed the direction or a critical stop decision.",
-            "**Use compact discovery for simple apps** — for concrete low-risk asks (todo app, landing page, local widget), do one context pass, compare one baseline and one challenger, then ask for one explicit approval; do not drag the user through a full workshop.",
+            "**Use compact discovery for low-risk asks** — for concrete bounded requests, do one context pass, compare one baseline and one challenger, then ask for one explicit approval; do not drag the user through a full workshop.",
             "**Early-exit concrete asks** — for unambiguous implementation-only requests, write a compact Problem Decision Record plus short-circuit handoff (context, approved intent, constraints, assumptions, next-stage risks) and ask for one explicit approval.",
             "**Ask only decision-changing questions** — one at a time; if answers would not change approach and are non-critical preference/default assumptions, state the assumption and continue; STOP on scope, architecture, security, data loss, public API, migration, auth/pricing, or user approval uncertainty.",
             "**Compare 2-3 distinct approaches with stable Role/Upside columns** — Role values are `baseline` | `challenger` | `wild-card`; Upside is `low` | `modest` | `high` | `higher`; include real trade-offs, reuse notes, and reference-pattern source/disposition when a known pattern influenced the option; include exactly one challenger with explicit `high` or `higher` upside.",
             "**Collect reaction before recommending** — ask which option feels closest and what concern remains, then recommend based on that reaction.",
             "**Write the `Not Doing` list** — name 3-5 things this brainstorm explicitly is not committing to (vs. deferred). This protects scope from silent enlargement and the next stage from rework.",
+            "**Run early Ralph loop discipline** — after each producer iteration, append a `Critic Pass` JSONL row to `.cclaw/state/early-loop-log.jsonl`, refresh `.cclaw/state/early-loop.json`, and iterate until open concerns clear or convergence guard escalates.",
+            "**Embedded Grill (post-pick)** — after `Selected Direction` is named, run 3-5 sharp checks on hidden constraints, reversibility/rollback, scope boundaries, existing-pattern conformance, and domain-language fit; record each question with recommended answer and disposition (accept/refine/reject).",
             "**Self-review before user approval** — re-read the artifact and patch contradictions, weak trade-offs, placeholders, ambiguity, and weak handoff language. Record the result in `Self-Review Notes` using the calibrated review format: `- Status: Approved` (or `Issues Found`), `- Patches applied:` with inline note or sub-bullets, `- Remaining concerns:` with inline note or sub-bullets. Use `Patches applied: None` and `Remaining concerns: None` when there is nothing to record.",
             "**Request explicit approval** — state exactly what direction is being approved; do not advance without approval and artifact review.",
-            "**Handoff** — only after approval, hand scope: upstream decisions used, explicit drift, confidence level, unresolved questions, next-stage risk hints, and non-goals."
+            "**Handoff packet** — only after approval, produce a scope handoff packet with selected direction, why rejected options were rejected, explicit non-goals, unresolved questions, risk hints, and explicit drift from the initial ask so scope starts from locked upstream decisions instead of rediscovering intent."
         ],
         interactionProtocol: [
             "Start from observed project context; if the idea is vague, first narrow the project type with **one** structured question, then keep going.",
@@ -59,7 +61,7 @@ export const BRAINSTORM = {
             "Lead with the premise check (right problem / direct path / what if nothing) and the `How Might We` reframing before approaches; both go in the artifact, not just the chat.",
             "Ask at most one question per turn, only when decision-changing; if using a structured question tool, send exactly one question object, not a multi-question form.",
             "Only non-critical preference/default assumptions may continue inline. STOP and ask when uncertainty affects scope, architecture, security, data loss, public API, migration, auth/pricing, or user approval.",
-            "For simple greenfield web apps, present a compact A/B choice with one recommended path and one higher-upside challenger; keep the artifact concise but structurally complete (Context, Premise, How Might We, Sharpening Questions, Approaches, Reaction, Selected Direction, Not Doing).",
+            "For simple low-risk greenfield work, present a compact A/B choice with one recommended path and one higher-upside challenger; keep the artifact concise but structurally complete (Context, Premise, How Might We, Sharpening Questions, Approaches, Reaction, Selected Direction, Not Doing).",
             "Show approaches before the recommendation; include a higher-upside challenger and gather reaction first.",
             "Self-review before approval: re-read the artifact, fix contradictions/placeholders/weak trade-offs, then ask for approval. Do not ask for approval on a draft you have not re-read.",
             "State exactly what is being approved, then **STOP** until the user explicitly approves the artifact."
@@ -87,11 +89,12 @@ export const BRAINSTORM = {
             "2-3 approaches with trade-offs are recorded, including one higher-upside challenger option and reference-pattern source/disposition when applicable.",
             "User reaction to approaches is captured before final recommendation.",
             "Final recommendation explicitly reflects user reaction.",
+            "Early-loop status is reflected via `Victory Detector` / `Critic Pass` sections and `.cclaw/state/early-loop.json` when concerns remain.",
             "Selected Direction includes the handoff to the track-aware next stage: scope on standard, spec on medium when scope/design are skipped.",
             "When a promising option is parked, a seed file is created under `.cclaw/seeds/` and referenced in the artifact.",
             "Approved direction and approval marker are present.",
             "Assumptions and open questions are captured (or explicitly marked as none).",
-            "Scope handoff includes upstream decisions used, explicit drift, confidence, unresolved questions, next-stage risk hints, and non-goals."
+            "Scope handoff packet includes selected direction, upstream decisions used, explicit drift, confidence, unresolved questions, next-stage risk hints, and non-goals."
         ],
         inputs: ["problem statement", "constraints", "success criteria"],
         requiredContext: [
@@ -141,10 +144,13 @@ export const BRAINSTORM = {
             { section: "Reference Pattern Candidates", required: false, validationRule: "Recommended when examples influence direction: list pattern/source, reusable invariant, accept/reject/defer disposition, and reason before approaches are finalized." },
             { section: "Approaches", required: true, validationRule: "Must compare 2-3 distinct options with real trade-offs. Use the canonical `Role` column with `baseline` | `challenger` | `wild-card` and the `Upside` column with `low` | `modest` | `high` | `higher`; include exactly one challenger row with `high` or `higher` upside, and cite reference-pattern source/disposition when applicable." },
             { section: "Approach Reaction", required: true, validationRule: "Must appear before Selected Direction and summarize user reaction before recommendation, including `Closest option`, `Concerns`, and what changed after reaction." },
-            { section: "Selected Direction", required: true, validationRule: "Must include the selected approach, explicit approval marker, rationale traceable to Approach Reaction, and scope handoff with decisions, drift, confidence, unresolved questions, risk hints, and non-goals." },
+            { section: "Selected Direction", required: true, validationRule: "Must include the selected approach, explicit approval marker, rationale traceable to Approach Reaction, and a scope handoff packet with selected direction, decisions, drift, confidence, unresolved questions, risk hints, and non-goals." },
+            { section: "Embedded Grill", required: false, validationRule: "Recommended after Selected Direction: 3-5 rows covering hidden constraints, reversibility/rollback, scope boundaries, existing-pattern fit, and domain-language alignment. Each row records question, recommended answer, and disposition (accept/refine/reject)." },
             { section: "Not Doing", required: false, validationRule: "Recommended: 3-5 explicitly non-committed items (distinct from deferred). Protects scope from silent enlargement and the next stage from rework." },
             { section: "Design", required: false, validationRule: "Must cover architecture, key components, and data flow scaled to complexity." },
             { section: "Visual Companion", required: false, validationRule: "If architecture/data-flow complexity is medium+, include compact ASCII/Mermaid diagram or explicitly justify omission." },
+            { section: "Victory Detector", required: false, validationRule: "Recommended early-loop checkpoint: cite `.cclaw/state/early-loop.json`, current iteration/maxIterations, open concern count, convergence status, and iterate/ready/escalate decision." },
+            { section: "Critic Pass", required: false, validationRule: "Recommended producer/critic log contract: each iteration appends one JSONL row to `.cclaw/state/early-loop-log.jsonl` with runId, stage, iteration, and open concerns." },
             { section: "Self-Review Notes", required: false, validationRule: "Recommended: use the calibrated review format — `- Status: Approved` (or `Issues Found`), `- Patches applied:` (inline note or sub-bullets, use `None` if nothing changed), `- Remaining concerns:` (inline note or sub-bullets, use `None` if nothing remains). Done before requesting user approval." },
             { section: "Assumptions and Open Questions", required: false, validationRule: "Must capture unresolved assumptions/open questions, or explicitly state none." }
         ],