cclaw-cli 4.0.0 → 5.0.0

package/dist/artifact-linter/shared.js

@@ -1,6 +1,7 @@
 import { SHIP_FINALIZATION_MODES } from "../constants.js";
 import { questionBudgetHint } from "../track-heuristics.js";
 import { FLOW_STAGES } from "../types.js";
+import { stageSchema } from "../content/stage-schema.js";
 /**
  * Recognized stop-signal phrases that satisfy the Q&A floor escape hatch
  * when recorded as a Q&A Log row. Mirrors `Stop Signals (Natural Language)`
@@ -29,9 +30,9 @@ const QA_LOG_STOP_SIGNAL_PATTERNS = [
     /(?<![\p{L}\p{N}_])рухаємось\s+далі(?![\p{L}\p{N}_])/iu
 ];
 /**
- * Stages that run adaptive elicitation. The `qa_log_below_min` rule only
- * fires for these. Other stages may still record a Q&A Log but no floor is
- * enforced.
+ * Stages that run adaptive elicitation. The `qa_log_unconverged` rule
+ * only fires for these. Other stages may still record a Q&A Log but no
+ * convergence floor is enforced.
  */
 export const ELICITATION_STAGES = new Set([
     "brainstorm",
@@ -39,9 +40,27 @@ export const ELICITATION_STAGES = new Set([
     "design"
 ]);
 /**
- * Decide whether a Q&A Log row counts as a "substantive" entry for the floor.
- * Rows whose disposition column reads `skipped` / `waived` only do not
- * count toward the minimum.
+ * Phrases that mark a Q&A Log row as "no new decision" — used by the
+ * Ralph-Loop convergence detector. When the last 2 substantive rows have
+ * a Decision impact tagged with one of these phrases, convergence has
+ * been reached even if not every forcing question was explicitly
+ * addressed.
+ */
+const QA_LOG_NO_DECISION_TOKENS = [
+    /\bskip(?:ped)?\b/iu,
+    /\bcontinue\b/iu,
+    /\bno[-\s]?change\b/iu,
+    /\bno[-\s]?decision\b/iu,
+    /\bno[-\s]?op\b/iu,
+    /\bnoop\b/iu,
+    /\bdone\b/iu,
+    /\bsame\b/iu,
+    /\bok\b/iu
+];
+/**
+ * Decide whether a Q&A Log row counts as a "substantive" entry. Rows
+ * whose decision_impact column reads `skipped` / `waived` only do not
+ * count.
  */
 function isSubstantiveQaRow(cells) {
     if (cells.length === 0)
@@ -53,8 +72,8 @@ function isSubstantiveQaRow(cells) {
     return true;
 }
 /**
- * Detect a stop-signal row in the Q&A Log. Pattern is matched across all
- * cells of any row so the user's quote can live in any column.
+ * Detect a stop-signal row in the Q&A Log. Pattern is matched across
+ * all cells of any row so the user's quote can live in any column.
  */
 function detectStopSignal(rows) {
     for (const row of rows) {
@@ -67,60 +86,185 @@ function detectStopSignal(rows) {
     return false;
 }
 /**
- * Evaluate the Q&A Log floor for a brainstorm / scope / design artifact.
- * Returns ok=true when the floor is satisfied or any escape hatch fires.
+ * Extract forcing-question topics from a stage's checklist. Looks for
+ * the canonical `**<Stage> forcing questions (must be covered or
+ * explicitly waived)** — <topic1>, <topic2>, ...` row and tokenizes the
+ * comma-separated topic list. Returns trimmed topic strings stripped of
+ * leading question words (`what`/`who`/`where`/`which`/`how`/`is`/`do`/`does`).
  *
- * Escape hatches (any one is sufficient):
- * - Q&A Log contains a stop-signal row.
+ * Returns empty array when no forcing-questions row is present (caller
+ * should treat absence as "no forcing requirement" — convergence falls
+ * back to the no-new-decisions / stop-signal detectors).
+ */
+export function extractForcingQuestions(stage) {
+    let checklist;
+    try {
+        checklist = stageSchema(stage).executionModel.checklist;
+    }
+    catch {
+        return [];
+    }
+    for (const row of checklist) {
+        const headerMatch = /\*\*\s*[A-Za-z]+\s+forcing\s+questions\s*\([^)]*\)\s*\*\*\s*(?:[—\-–:]+)?\s*(.+)/iu.exec(row);
+        if (!headerMatch)
+            continue;
+        const body = (headerMatch[1] ?? "")
+            .replace(/\.$/u, "")
+            .trim();
+        if (body.length === 0)
+            return [];
+        return body
+            .split(/,\s*(?:and\s+)?|\s+and\s+/iu)
+            .map((topic) => topic.trim())
+            .filter((topic) => topic.length > 0)
+            .map((topic) => topic
+            .replace(/^[*_`]+|[*_`]+$/gu, "")
+            .replace(/^(?:what|who|where|which|how|is|are|do|does|did|can|will|would|could|should|may|might)\s+/iu, "")
+            .replace(/\?+$/u, "")
+            .trim())
+            .filter((topic) => topic.length > 0);
+    }
+    return [];
+}
+/**
+ * Build a salient-keyword set for a forcing-question topic. Splits on
+ * whitespace, drops short/stop words, lowercases. Used for fuzzy
+ * substring match against Q&A Log row content.
+ */
+function topicKeywords(topic) {
+    const STOP_WORDS = new Set([
+        "the", "a", "an", "is", "are", "was", "were", "be", "to", "of", "in", "on", "at",
+        "for", "and", "or", "but", "if", "then", "else", "with", "without", "by", "as",
+        "we", "us", "our", "they", "them", "their", "you", "your", "i", "me", "my",
+        "this", "that", "these", "those", "it", "its", "do", "does", "did", "can",
+        "will", "would", "should", "could", "may", "might", "any", "some", "no", "not",
+        "from", "into", "onto", "upon", "than", "very", "much", "many", "more", "most",
+        "must", "have", "has", "had", "been", "being", "where", "when", "while",
+        "what", "which", "who", "whose", "whom", "why", "how", "non"
+    ]);
+    return topic
+        .toLowerCase()
+        .split(/[\s\-/.,;:()\[\]{}'"`*_]+/u)
+        .map((token) => token.replace(/[^\p{L}\p{N}-]/gu, ""))
+        .filter((token) => token.length >= 3 && !STOP_WORDS.has(token));
+}
+function isTopicAddressed(topic, rows) {
+    const keywords = topicKeywords(topic);
+    if (keywords.length === 0)
+        return true;
+    const minHits = keywords.length === 1 ? 1 : Math.min(2, keywords.length);
+    for (const row of rows) {
+        const haystack = row.join(" | ").toLowerCase();
+        let hits = 0;
+        for (const keyword of keywords) {
+            if (haystack.includes(keyword))
+                hits += 1;
+            if (hits >= minHits)
+                return true;
+        }
+    }
+    return false;
+}
+function lastTwoRowsAllNoDecision(substantiveRows) {
+    if (substantiveRows.length < 2)
+        return false;
+    const tail = substantiveRows.slice(-2);
+    for (const row of tail) {
+        const decisionImpact = (row[row.length - 1] ?? "").trim();
+        if (decisionImpact.length === 0)
+            return false;
+        const matched = QA_LOG_NO_DECISION_TOKENS.some((pattern) => pattern.test(decisionImpact));
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+/**
+ * Evaluate the Q&A Log convergence floor for a brainstorm / scope /
+ * design artifact. Returns ok=true when convergence is reached or any
+ * escape hatch fires.
+ *
+ * Convergence sources (any one is sufficient):
+ * - All forcing-question topics from the stage checklist appear addressed
+ *   in `## Q&A Log` (substring keyword match in question/answer columns).
+ * - The Ralph-Loop convergence detector reports the last 2 substantive
+ *   rows have decision_impact marking `skip`/`continue`/`no-change`/`done`
+ *   (i.e. the dialogue is no longer producing decision-changing rows).
+ * - Q&A Log contains a stop-signal row (existing
+ *   `QA_LOG_STOP_SIGNAL_PATTERNS` keep working).
  * - `--skip-questions` flag was persisted to the active stage flags
- *   (passed via `options.skipQuestions=true`); finding downgrades to advisory.
- * - Track is `quick` (lite tier ~ lightweight complexity) AND substantive
- *   count >= 1.
+ *   (`options.skipQuestions=true`); finding downgrades to advisory.
+ * - The stage checklist exposes no forcing-questions row (e.g. simple
+ *   refactor) AND the artifact has at least one substantive row — treat
+ *   as converged because there is nothing left to force.
+ *
+ * Wave 23 (v5.0.0) replaces the count-based `qa_log_below_min` rule with
+ * `qa_log_unconverged`. The fixed count constant (10 for standard) and
+ * the `CCLAW_ELICITATION_FLOOR=advisory` env override were removed. The
+ * `min` and `liteShortCircuit` fields on the result are retained for
+ * harness UI compatibility but are always 0/false.
  */
 export function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
-    const hint = questionBudgetHint(track, stage);
-    const min = hint.min;
     const rows = qaLogBody !== null ? getMarkdownTableRows(qaLogBody) : [];
     const substantiveRows = rows.filter(isSubstantiveQaRow);
     const count = substantiveRows.length;
     const hasStopSignal = detectStopSignal(rows);
-    const liteShortCircuit = track === "quick" && count >= 1;
-    // Emergency override (undocumented for users): set
-    // `CCLAW_ELICITATION_FLOOR=advisory` to downgrade qa_log_below_min from
-    // blocking to advisory globally. This is a safety net for incidents where
-    // the floor mis-fires across an org; treat as `--skip-questions` semantics.
-    const envOverride = (typeof process !== "undefined" ? process.env?.CCLAW_ELICITATION_FLOOR : undefined) === "advisory";
-    const skipQuestionsAdvisory = options.skipQuestions === true || envOverride;
-    const ok = count >= min || hasStopSignal || liteShortCircuit;
+    const skipQuestionsAdvisory = options.skipQuestions === true;
+    const forcingTopics = options.forcingQuestions ?? extractForcingQuestions(stage);
+    const forcingCovered = [];
+    const forcingPending = [];
+    for (const topic of forcingTopics) {
+        if (isTopicAddressed(topic, rows))
+            forcingCovered.push(topic);
+        else
+            forcingPending.push(topic);
+    }
+    const noNewDecisions = lastTwoRowsAllNoDecision(substantiveRows);
+    const allForcingCovered = forcingTopics.length > 0 ? forcingPending.length === 0 : count >= 1;
+    const ok = allForcingCovered || noNewDecisions || hasStopSignal;
     let details;
     if (ok) {
-        if (count >= min) {
-            details = `Q&A Log has ${count} substantive entries (floor for ${track}/${stage}: ${min}).`;
+        if (allForcingCovered && forcingTopics.length > 0) {
+            details = `Q&A Log converged: all ${forcingTopics.length} forcing-question topic(s) addressed across ${count} substantive row(s).`;
         }
-        else if (hasStopSignal) {
-            details = `Q&A Log has ${count} substantive entries with an explicit user stop-signal row recorded (floor: ${min}).`;
+        else if (allForcingCovered) {
+            details = `Q&A Log converged: stage exposes no forcing-questions row and ${count} substantive entry recorded.`;
+        }
+        else if (noNewDecisions) {
+            const remaining = forcingPending.length > 0
+                ? ` ${forcingPending.length} forcing topic(s) still pending but last 2 rows produced no decision changes (Ralph-Loop convergence).`
+                : " Ralph-Loop convergence detector says no new decision-changing rows in the last 2 turns.";
+            details = `Q&A Log converged via no-new-decisions detector at ${count} row(s).${remaining}`;
         }
         else {
-            details = `Q&A Log has ${count} substantive entry under lightweight track short-circuit (default floor: ${min}).`;
+            details = `Q&A Log converged: explicit user stop-signal row recorded at ${count} row(s).`;
         }
     }
     else if (skipQuestionsAdvisory) {
-        const reason = options.skipQuestions === true
-            ? "--skip-questions flag was set"
-            : "CCLAW_ELICITATION_FLOOR=advisory env override is active";
-        details = `Q&A Log has ${count} substantive entries, minimum for ${track}/${stage} is ${min}; ${reason}, finding downgraded to advisory.`;
+        details = `Q&A Log unconverged at ${count} row(s); --skip-questions flag downgraded the finding to advisory. Pending forcing topic(s): ${forcingPending.length > 0 ? forcingPending.join("; ") : "(none extracted)"}.`;
     }
     else {
-        details = `Q&A Log has ${count} substantive entries, minimum for ${track}/${stage} is ${min}. Continue the elicitation loop or record an explicit user stop-signal row in Q&A Log.`;
+        details = `Q&A Log unconverged at ${count} row(s). Continue the elicitation loop until forcing-question topics are addressed (${forcingPending.length > 0 ? forcingPending.join("; ") : "no forcing topics extracted"}), the last 2 rows record no-decision impact, or an explicit user stop-signal row is appended.`;
     }
+    // Surface advisory budget hint for harness UI without re-introducing a
+    // blocking count. `recommended` is the soft budget per track/stage.
+    const advisoryBudget = questionBudgetHint(track, stage).recommended;
     return {
         ok,
         count,
-        min,
+        // Wave 23: floor no longer enforces a count. Surfacing 0 keeps the
+        // QaLogFloorSignal shape stable for harness consumers; harness UIs
+        // may show `recommended` from `questionBudgetHint` separately.
+        min: 0,
         hasStopSignal,
-        liteShortCircuit,
+        liteShortCircuit: false,
         skipQuestionsAdvisory,
-        details
+        forcingCovered,
+        forcingPending,
+        noNewDecisions,
+        details: advisoryBudget > 0
+            ? `${details} (advisory budget for ${track}/${stage}: ~${advisoryBudget} Q&A turns)`
+            : details
     };
 }
 export function normalizeHeadingTitle(title) {
@@ -678,61 +822,12 @@ export function extractCanonicalScopeMode(body) {
     }
     return null;
 }
-export function validatePremiseChallenge(sectionBody) {
-    // gstack-style premise challenge requires a real Q/A structure (table or
-    // list), not free-form prose. The validation is *structural* only — we do
-    // NOT keyword-grep for English phrases like "right problem"; authors may
-    // write the questions in any language, and the answers carry the meaning.
-    // The template ships with canonical question labels as scaffolding, but
-    // the linter only enforces that the section actually compares premise
-    // questions to answers.
-    const tableRows = getMarkdownTableRows(sectionBody);
-    const bulletRows = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-    const rowCount = Math.max(tableRows.length, bulletRows.length);
-    if (rowCount < 3) {
-        return {
-            ok: false,
-            details: `Premise Challenge needs at least 3 substantive rows in a table or bullet list. Found ${rowCount}.`
-        };
-    }
-    // For tables, each data row must have at least 2 non-empty cells so the
-    // section is genuinely a premise/answer comparison, not a list of headlines.
-    // For bullet lists, each line must be substantive so we don't accept
-    // placeholders like `- a`; punctuation style and natural language do not
-    // matter.
-    if (tableRows.length >= 3) {
-        const sparseRows = tableRows.filter((row) => {
-            const filledCells = row.filter((cell) => cell.replace(/[\s|]/gu, "").length >= 2);
-            return filledCells.length < 2;
-        });
-        if (sparseRows.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge table rows must populate at least the question and answer columns (no empty answers)."
-            };
-        }
-    }
-    else if (bulletRows.length >= 3) {
-        const sparseBullets = bulletRows.filter((line) => {
-            const cleaned = line.replace(/^[-*\d.\s]+/u, "").replace(/[`*_]/gu, "").trim();
-            const meaningful = cleaned.match(/[\p{L}\p{N}]/gu)?.length ?? 0;
-            return meaningful < 12;
-        });
-        if (sparseBullets.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge bullet list must include at least 3 substantive rows, not placeholders."
-            };
-        }
-    }
-    return {
-        ok: true,
-        details: `Premise Challenge structures ${rowCount} Q/A rows.`
-    };
-}
+// `validatePremiseChallenge` was removed in Wave 23 (v5.0.0). Premise
+// challenge is now owned solely by brainstorm (`## Premise Check`); scope
+// only records `## Premise Drift` when scope-stage Q&A surfaces new
+// evidence that materially changes the brainstorm answer. The drift
+// section is optional and structural-only via the default `validateSectionBody`
+// path (no specialized validator required).
 export function validateScopeSummary(sectionBody) {
     const meaningfulLines = sectionBody
         .split(/\r?\n/)
@@ -1551,9 +1646,6 @@ export function validateSectionBody(sectionBody, rule, sectionName) {
     if (sectionNameNormalized === "scope summary") {
         return validateScopeSummary(sectionBody);
     }
-    if (sectionNameNormalized === "premise challenge") {
-        return validatePremiseChallenge(sectionBody);
-    }
     if (sectionNameNormalized.startsWith("requirements")) {
         return validateRequirementsTaxonomy(sectionBody);
     }

package/dist/artifact-linter.d.ts

@@ -1,6 +1,6 @@
 import type { FlowStage, FlowTrack } from "./types.js";
 import { type LintResult } from "./artifact-linter/shared.js";
-export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, type ReviewVerdictConsistencyResult, type ReviewSecurityNoChangeAttestationResult } from "./artifact-linter/review-army.js";
+export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, checkReviewTddNoCrossArtifactDuplication, type ReviewVerdictConsistencyResult, type ReviewSecurityNoChangeAttestationResult, type ReviewTddDuplicationConflict, type ReviewTddDuplicationResult } from "./artifact-linter/review-army.js";
 export { type LintFinding, type LintResult, type LearningEntryType, type LearningConfidence, type LearningSeverity, type LearningSource, type LearningSeedEntry, type LearningsParseResult, extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
 export interface LintArtifactOptions {
     /**

package/dist/artifact-linter.js

@@ -12,7 +12,7 @@ import { lintSpecStage } from "./artifact-linter/spec.js";
 import { lintTddStage } from "./artifact-linter/tdd.js";
 import { lintReviewStage } from "./artifact-linter/review.js";
 import { lintShipStage } from "./artifact-linter/ship.js";
-export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation } from "./artifact-linter/review-army.js";
+export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, checkReviewTddNoCrossArtifactDuplication } from "./artifact-linter/review-army.js";
 export { extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
 const FRONTMATTER_REQUIRED_KEYS = [
     "stage",

package/dist/content/core-agents.js

@@ -392,7 +392,12 @@ export const CCLAW_AGENTS = [
             "Compatibility: NO_IMPACT / FOUND_<n>",
             "Observability: NO_IMPACT / FOUND_<n>",
             "Security: routed to security-reviewer (always separate)",
-            "For unusually large/high-risk diffs, optional deep-dive context skills may be loaded: `review-perf-lens`, `review-compat-lens`, `review-observability-lens`.",
+            "",
+            "### Companion lens skills (load on-demand, never all-at-once)",
+            "- **review-perf-lens** — load when reviewing code touching hot paths, loops over large data, network/disk I/O, render hot paths, or sub-100ms latency budgets.",
+            "- **review-compat-lens** — load when reviewing code that runs on multiple OS/runtime/browser targets, modifies shared library APIs, or changes serialized payload shapes.",
+            "- **review-observability-lens** — load when reviewing code that adds/removes logging, metrics, traces, error reporting, or audit/compliance signals.",
+            "If none of those triggers apply, do NOT load the lens skills — they are deep-dive context, not default reading.",
             "",
             "For each finding include:",
             "- Severity: `Critical` | `Important` | `Suggestion`",

package/dist/content/idea.js

@@ -247,7 +247,12 @@ ${frameBullets}
 8. **Write the artifact** at
    \`${IDEA_ARTIFACT_PATTERN}\` using the schema in the skill.
 9. **Present the handoff prompt** with four concrete options - not A/B/C
-   letters. Default = "Start /cc on the top recommendation".
+   letters. Default = "Start /cc on the top recommendation". When the user
+   picks the start option, plumb the chosen candidate forward via
+   \`start-flow --from-idea-artifact=<path> --from-idea-candidate=I-<n>\`
+   (Wave 23 / v5.0.0) so brainstorm reuses the idea's divergent + critique +
+   rank work via \`interactionHints.brainstorm.fromIdeaArtifact\`; do NOT
+   ask brainstorm to regenerate it.
 
 ## Headless mode (CI/automation only)
 
@@ -390,7 +395,14 @@ Required options, in this order:
 ### Phase 6 - Execute the choice
 
 - Start /cc: load \`${RUNTIME_ROOT}/skills/using-cclaw/SKILL.md\` and run
-  \`/cc <phrase>\`.
+  \`/cc <phrase>\`. **Wave 23 (v5.0.0) handoff carry-forward (mandatory when starting from /cc-idea):**
+  the harness shim that turns \`/cc <phrase>\` into a \`start-flow\` invocation
+  MUST forward the originating idea artifact and chosen candidate so brainstorm
+  reuses divergent + critique + rank work instead of redoing it. Equivalent CLI
+  call (used by automation; harness handles this transparently in interactive mode):
+  \`npx cclaw-cli internal start-flow --track=<track> --prompt='<phrase>' --from-idea-artifact=${IDEA_ARTIFACT_PATTERN} --from-idea-candidate=I-<n>\`.
+  The hint lands in \`flow-state.interactionHints.brainstorm\` and brainstorm's
+  \`Idea-evidence carry-forward\` checklist row picks it up.
 - Save and close: reply with artifact path and stop.
 - Discard: delete the artifact and stop.
 

package/dist/content/skills-elicitation.js

@@ -47,7 +47,7 @@ These behaviors are the exact reason this skill exists. The linter will block yo
 - Ask exactly one question per turn and wait for the answer before asking the next one.
 - Use harness-native question tools first; prose fallback is allowed only when the tool is unavailable.
 - Keep a running Q&A trace in the active artifact under \`## Q&A Log\` in \`${RUNTIME_ROOT}/artifacts/\` as append-only rows.
-- **Hard floor**: do NOT advance the stage (do NOT call \`stage-complete.mjs\`) until \`## Q&A Log\` contains at least \`min(track, stage)\` substantive entries OR an explicit user stop-signal is recorded as a row. The linter rule \`qa_log_below_min\` enforces this; \`stage-complete\` will fail otherwise.
+- **Convergence floor**: do NOT advance the stage (do NOT call \`stage-complete.mjs\`) until Q&A converges. Convergence is reached when ANY of: (a) all forcing-question topics are addressed in \`## Q&A Log\`, (b) the last 2 substantive rows produce no decision-changing impact (\`skip\`/\`continue\`/\`no-change\`/\`done\`), or (c) an explicit user stop-signal row is recorded. The linter rule \`qa_log_unconverged\` enforces this; \`stage-complete\` will fail otherwise. Wave 23 (v5.0.0) replaced the fixed-count floor with this convergence detector.
 - **NEVER run shell hash commands** (\`shasum\`, \`sha256sum\`, \`md5sum\`, \`Get-FileHash\`, \`certutil\`, etc.) to compute artifact hashes. If a linter ever asks you for a hash, that is a linter bug — report failure and stop, do not auto-fix in bash.
 - **NEVER paste cclaw command lines into chat** (e.g. \`node .cclaw/hooks/stage-complete.mjs ... --evidence-json '{...}'\`). Run them via the tool layer; report only the resulting summary. The user does not run cclaw manually and seeing the command line is noise.
 
@@ -103,16 +103,19 @@ Each grill question follows the same Core Protocol: ask one, wait, log, self-eva
 
 Do not ask extra questions "for theater" on simple low-risk work.
 
-## Question Budget Hint (linter-enforced floor)
+## Question Budget Hint (advisory only — Wave 23 dropped the count floor)
 
-Source of truth: \`questionBudgetHint(track, stage)\`. The \`Min\` column is enforced by \`qa_log_below_min\` linter rule — \`stage-complete\` fails when below.
+Source of truth: \`questionBudgetHint(track, stage)\`. The numbers below are
+**soft hints** for harness UI and elicitation pacing; gate blocking is done
+by the \`qa_log_unconverged\` rule (Ralph-Loop convergence detector), NOT by
+a fixed count.
 
 ${budgetTable}
 
 Track mapping note: \`quick\` ~= lightweight, \`medium\` ~= standard, \`standard\` ~= deep.
 
 How to use the columns:
-- \`Min\` — hard floor. Below this, \`stage-complete\` is blocked unless escape hatch is recorded.
+- \`Min\` — soft minimum to surface forcing questions; not a blocking gate.
 - \`Recommended\` — target for normal flows.
 - \`Hard cap warning\` — point at which to stop or compress remaining forcing questions into one final batched ask. Not skip.
 

package/dist/content/stage-schema.js

@@ -439,6 +439,16 @@ const STAGE_SCHEMA_MAP = {
     review: REVIEW,
     ship: SHIP
 };
+/**
+ * Stage-level subagent dispatch matrix.
+ *
+ * NOTE on `fixer`: the `fixer` agent is intentionally NOT listed in any stage
+ * row. It is dispatched on-demand by the SDD `subagent-dev` skill (and by
+ * reviewer flows) when a review surfaces a concrete failing criterion that
+ * needs a fresh worker. Adding `fixer` to the static matrix would create
+ * proactive-waiver theatre because it can only run after a specific review
+ * finding exists. See `core-agents.ts` `fixer` definition for the contract.
+ */
 const STAGE_AUTO_SUBAGENT_DISPATCH = {
     brainstorm: [
         {

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

@@ -18,8 +18,7 @@ const STAGE_POLICY_NEEDLES = {
         "In Scope",
         "Out of Scope",
         "Discretion Areas",
-        "NOT in scope",
-        "Premise Challenge",
+        "Premise Drift",
         "Locked Decisions",
         "Victory Detector",
         "Critic Pass"

package/dist/content/stages/brainstorm.js

@@ -36,7 +36,7 @@ export const BRAINSTORM = {
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the brainstorm forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer. Continue until all forcing questions are answered/skipped/waived OR user records an explicit stop-signal row. Only then proceed to delegations, drafts, or analysis. The linter `qa_log_below_min` rule will block `stage-complete` if Q&A Log is below floor.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the brainstorm forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer. Continue until forcing-questions converge (all answered/skipped/waived) OR Ralph-Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to delegations, drafts, or analysis. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
             "**Explore project context** — after the elicitation loop converges, inspect existing files/docs/recent activity to refine the Discovered context section; capture matching files/patterns/seeds in `Context > Discovered context` so downstream stages don't redo discovery.",
             "**Brainstorm forcing questions (must be covered or explicitly waived)** — what pain are we solving, what is the direct path, what happens if we do nothing, who is the first operator/user affected, and what no-go boundaries are non-negotiable.",
             "**Classify stage depth** — choose `lite` for clear low-risk tasks, `standard` for normal engineering/product changes, or `deep` for ambiguity, architecture, external dependency, security/data risk, or explicit think-bigger requests.",
@@ -48,6 +48,7 @@ export const BRAINSTORM = {
             "**Use compact discovery for low-risk asks** — for concrete bounded requests, do one context pass, compare one baseline and one challenger, and move to draft once context is sufficient; 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 request explicit approval when the draft is ready.",
             "**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.",
+            "**Idea-evidence carry-forward (when applicable).** If `flow-state.interactionHints.brainstorm.fromIdeaArtifact` is set, read that idea artifact and reuse its `Title`, `Why-now`, `Expected impact`, `Risk`, `Counter-argument` for the chosen `I-#` (`fromIdeaCandidateId`) as the seed of `## Selected Direction` and as one row of `## Approaches` (role: `baseline`, evidence: idea-artifact path). Generate ONLY the missing higher-upside `challenger` row(s); do NOT re-generate the candidate that came from `/cc-ideate`. Record the carry-forward in `## Idea Evidence Carry-forward` with at minimum `- Source: <path>`, `- Candidate: <I-#>`, `- Reused fields: Title, Why-now, Expected impact, Risk, Counter-argument`, `- Newly generated: challenger(s) only`.",
             "**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.",
@@ -91,6 +92,7 @@ export const BRAINSTORM = {
             "Clarity Gate records ambiguity score, decision boundaries, reaffirmed non-goals, and residual-risk handoff.",
             "Clarifying questions are one-at-a-time and captured only when they change a decision or stop condition.",
             "2-3 approaches with trade-offs are recorded, including one higher-upside challenger option and reference-pattern source/disposition when applicable.",
+            "When `flow-state.interactionHints.brainstorm.fromIdeaArtifact` is set, the `## Idea Evidence Carry-forward` section cites the idea artifact + `I-#` and only the challenger rows are newly generated (idea candidate is reused as `baseline`, never re-derived).",
             "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.",
@@ -146,6 +148,7 @@ export const BRAINSTORM = {
             { section: "Approach Tier", required: true, validationRule: "Must classify depth as lite/standard/deep and explain the risk/uncertainty signal." },
             { section: "Short-Circuit Decision", required: false, validationRule: "Must include Status/Why/Scope handoff lines when short-circuit is discussed; compact stubs are valid for concrete asks." },
             { 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: "Idea Evidence Carry-forward", required: false, validationRule: "Wave 23 (v5.0.0): when `flow-state.interactionHints.brainstorm.fromIdeaArtifact` is set, this section MUST cite the idea artifact path and the chosen `I-#`, list reused fields (Title, Why-now, Expected impact, Risk, Counter-argument), and explicitly state that only challenger row(s) were newly generated. Honors `/cc-ideate` handoff so divergent + critique + rank work is reused, not redone." },
             { 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 a scope handoff packet with selected direction, decisions, drift, confidence, unresolved questions, risk hints, and non-goals." },

package/dist/content/stages/design.js

@@ -34,19 +34,22 @@ export const DESIGN = {
             "Skipping outside-voice review loop and treating first draft as final",
             "Batching multiple design issues into one question",
             "Agreeing with user's architecture choice without evaluating alternatives",
-            "No NOT-in-scope output section",
+            "Re-authoring scope's out-of-scope list instead of citing it via Upstream Handoff",
+            "Re-authoring scope's repo audit instead of diffing the blast radius since scope baseline",
             "Design decisions made without reading the actual code first"
         ]
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the design forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer. Continue until all forcing questions are answered/skipped/waived OR user records an explicit stop-signal row. Only then proceed to research, investigator pass, architecture lock, or any delegations. The linter `qa_log_below_min` rule will block `stage-complete` if Q&A Log is below floor.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the design forcing questions one-at-a-time via the harness-native question tool, append one row to `## Q&A Log` (`Turn | Question | User answer (1-line) | Decision impact`) after each user answer. Continue until forcing-questions converge (all answered/skipped/waived) OR Ralph-Loop convergence detector says no new decision-changing rows in last 2 iterations OR user records an explicit stop-signal row. Only then proceed to research, investigator pass, architecture lock, or any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
             "**Design forcing questions (must be covered or explicitly waived)** — what is the end-to-end data flow, where are seams/ownership boundaries, which invariants must hold, and what will explicitly NOT be refactored now.",
+            "**Out-of-scope carry-forward (do NOT re-author)** — scope OWNS the out-of-scope list. Cite scope's `## In Scope / Out of Scope > Out of Scope` via `## Upstream Handoff > Decisions carried forward`; do NOT add a separate `## NOT in scope` section in the design artifact. Add a row to `## Spec Handoff` only if a design-stage decision NEWLY excludes something not already in scope's out-of-scope.",
             "Compact design lock — design does not decide what to build; it decides how the approved scope works. For simple slices, produce a tight lock: upstream handoff, existing fit, architecture boundary, one labeled diagram, data/state flow, critical path, failure/rescue, trust boundaries, test/perf expectations, rollout/rollback, rejected alternative, and spec handoff.",
             "Trivial-Change Escape Hatch — for <=3 files, no new interfaces, and no cross-module data flow, produce a mini-design (rationale, changed files, one risk) and proceed to spec.",
+            "**Architecture choice (design OWNS the tier decision)** — pick the architecture tier (minimum-viable / product-grade / ideal) using scope's `## Scope Contract > Design handoff` as the input. Record the tier and rationale in `## Architecture Decision Record (ADR)` and `## Engineering Lock`. Scope only locked the SCOPE MODE; it did NOT enumerate Implementation Alternatives.",
             "Tiered Research — for simple/medium work, do compact inline codebase/research synthesis in `Research Fleet Synthesis`; write `.cclaw/artifacts/02a-research.md` and run the full fleet only for deep/high-risk work or when external framework/architecture uncertainty exists.",
             "Design Doc Check — read upstream artifacts and current design docs; latest superseding doc wins.",
-            "Investigator pass — before design decisions, read blast-radius code and record touched files, responsibilities, reuse candidates, and existing patterns.",
+            "**Blast-radius diff (do NOT re-audit the whole repo)** — scope OWNS the full repo audit (`## Pre-Scope System Audit`). Design only diffs the blast radius SINCE scope baseline: `git diff <scope-artifact-head-sha>..HEAD -- <touched-paths>`. Record touched files, current responsibilities, reuse candidates, and existing patterns in `## Codebase Investigation` and `## Blast-radius Diff`. Do NOT re-author scope's git log/diff/stash audit.",
             "Scope Challenge + Search Before Building — find existing solutions, minimum change set, reference-grade contracts to mirror, and complexity smells before custom architecture.",
             "Architecture Review — lock boundaries, chosen path, shadow alternative, switch trigger, failure/rescue/degraded behavior, and verification evidence for every high-risk choice; include tier-required diagrams.",
             "Review core risk areas — existing system fit, data/state flow, critical path, security/trust boundaries, tests, performance budget, observability/debuggability, rollout/rollback, rejected alternatives, and spec handoff.",
@@ -77,7 +80,7 @@ export const DESIGN = {
             "Walk review sections interactively and lock boundaries, data flow, state transitions, edge cases, and failure modes.",
             "Cover security, observability, deployment, tests, and performance for Standard+ changes.",
             "Run stale-diagram audit (enabled by default unless explicitly disabled).",
-            "Produce required outputs: NOT-in-scope, What-already-exists, tier diagrams, failure table, completion dashboard.",
+            "Produce required outputs: blast-radius diff (scope owns full repo audit), tier diagrams, failure table, completion dashboard. Out-of-scope is carried from scope via Upstream Handoff — do NOT re-author it.",
             "Plant high-upside deferred ideas when useful and reconcile critic/outside-voice findings.",
             "Write design lock artifact for downstream spec/plan with design decisions, rejected alternatives, verification evidence, and exact spec handoff."
         ],
@@ -107,8 +110,8 @@ export const DESIGN = {
             "Test-Diagram Mapping links critical flows to both validating tests and diagram anchors.",
             "Test strategy includes unit/integration/e2e expectations.",
             "When a high-upside idea is deferred, a seed file is created under `.cclaw/seeds/` and referenced in the artifact.",
-            "NOT-in-scope section produced.",
-            "What-already-exists section produced.",
+            "Out-of-scope is carried forward from scope's `## In Scope / Out of Scope > Out of Scope` via `## Upstream Handoff > Decisions carried forward`; design does NOT author its own NOT-in-scope section.",
+            "Blast-radius Diff section produced (git diff since scope artifact baseline) — scope owns the full repo audit; design only diffs touched paths.",
             "Completion dashboard lists review section status, critical/open gap counts, decision count, and unresolved items (or 'None')."
         ],
         inputs: ["scope agreement artifact", "system constraints", "non-functional requirements"],
@@ -174,7 +177,7 @@ export const DESIGN = {
             { section: "Performance Budget", required: false, validationRule: "For each critical path: metric name, target threshold, and measurement method." },
             { section: "Observability & Debuggability", required: true, validationRule: "Must define logs/metrics/traces plus alerting/debug path for critical failure modes." },
             { section: "Deployment & Rollout", required: true, validationRule: "Must define migration/flag strategy, rollout/rollback plan, switch trigger, and post-deploy verification steps." },
-            { section: "What Already Exists", required: false, validationRule: "For each sub-problem: existing code/library found (Layer 1-3/EUREKA label), reuse decision, and adaptation needed." },
+            { section: "Blast-radius Diff", required: false, validationRule: "Diff since scope artifact baseline (`git diff <scope-sha>..HEAD -- <touched-paths>`): for each touched file, summarize change since scope, current responsibility, reuse candidate, and existing pattern. Scope OWNS the full repo audit; design only diffs the blast radius." },
             { section: "Reference-Grade Contracts", required: false, validationRule: "For every mirrored pattern: source, reusable invariant, local adaptation, rejection boundary, and verification signal. Omit with `None - no external or in-repo pattern mirrored` for compact local changes." },
             { section: "Rejected Alternatives", required: false, validationRule: "List alternatives considered, why rejected, and what signal would revive them." },
             { section: "Design Decisions", required: false, validationRule: "Stable design decisions with requirement/locked-decision refs and downstream spec impact." },
@@ -184,10 +187,9 @@ export const DESIGN = {
             { section: "Design Outside Voice Loop", required: false, validationRule: `Record iteration table with quality score per iteration, stop reason, and unresolved concerns. Enforce ${reviewLoopPolicySummary("design")}` },
             { 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: "NOT in scope", required: false, validationRule: "Work considered and explicitly deferred with one-line rationale." },
             { section: "Completion Dashboard", required: true, validationRule: "Lists every review section with status (clear / issues-found-resolved / issues-open), critical/open gap counts, decision count, and unresolved items (or 'None')." }
         ],
-        trivialOverrideSections: ["Architecture Boundaries", "NOT in scope", "Completion Dashboard"]
+        trivialOverrideSections: ["Architecture Boundaries", "Completion Dashboard"]
     },
     reviewLens: {
         outputs: [
@@ -195,8 +197,7 @@ export const DESIGN = {
             "architecture lock",
             "risk and failure map",
             "test and performance baseline",
-            "NOT-in-scope section",
-            "What-already-exists section",
+            "blast-radius diff since scope baseline",
             "design decisions and spec handoff",
             "design completion dashboard"
         ],