cclaw-cli 4.0.0 → 6.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,211 @@ 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.
+ * Validate the kebab-case ASCII shape of a forcing-question topic ID.
+ * Wave 24 enforces that IDs are short, language-neutral identifiers
+ * authors can paste into a `[topic:<id>]` tag without typos.
+ */
+const TOPIC_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;
+function isValidTopicId(id) {
+    return TOPIC_ID_PATTERN.test(id);
+}
+/**
+ * Parse a single checklist row into the list of forcing-question topic
+ * descriptors it declares. Returns `null` when the row is not a
+ * forcing-questions header. Throws when the header is found but its
+ * body does not match the Wave 24 `id: topic; id: topic; ...` syntax
+ * — authors fix the stage definition rather than silently ship
+ * un-coverable topics.
+ *
+ * Exposed for unit tests that exercise the parser without depending on
+ * the live stage schema.
+ */
+export function parseForcingQuestionsRow(row, context = "row") {
+    const headerMatch = /\*\*\s*[A-Za-z]+\s+forcing\s+questions\s*\([^)]*\)\s*\*\*\s*(?:[—\-–:]+)?\s*(.+)/iu.exec(row);
+    if (!headerMatch)
+        return null;
+    const body = (headerMatch[1] ?? "").trim();
+    if (body.length === 0)
+        return [];
+    // Take everything up to the first sentence-ending `.` followed by a
+    // space + capital letter. We split on `;` only; commas are part of
+    // human labels. Authors stop the list with `.` so the trailing
+    // prose ("Tag the matching ...") is excluded.
+    const listSection = body.split(/\.\s+(?=[A-Z])/u)[0] ?? body;
+    const segments = listSection
+        .split(/;\s*/u)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+    const topics = [];
+    for (const segment of segments) {
+        const match = /^[`*_]?\s*([A-Za-z0-9][A-Za-z0-9-]*)\s*[`*_]?\s*:\s*(.+?)\s*$/u.exec(segment);
+        if (!match) {
+            throw new Error(`parseForcingQuestionsRow(${context}): segment "${segment}" does not match required \`id: topic\` syntax. Wave 24 (v6.0.0) requires \`id: topic; id: topic; ...\` form.`);
+        }
+        const id = (match[1] ?? "").toLowerCase();
+        const topic = (match[2] ?? "").replace(/[`*_]+$/u, "").trim();
+        if (!isValidTopicId(id)) {
+            throw new Error(`parseForcingQuestionsRow(${context}): invalid topic id "${id}" in segment "${segment}". IDs must match ${TOPIC_ID_PATTERN.source}.`);
+        }
+        if (topic.length === 0) {
+            throw new Error(`parseForcingQuestionsRow(${context}): empty topic label after id "${id}" in segment "${segment}".`);
+        }
+        topics.push({ id, topic });
+    }
+    return topics;
+}
+/**
+ * Extract forcing-question topics from a stage's checklist.
+ *
+ * Wave 24 (v6.0.0): only the new `id: topic; id: topic; ...` syntax is
+ * accepted. Throws when the syntax is malformed so authors fix the
+ * stage definition rather than silently shipping un-coverable topics.
  *
- * 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
+ * treats absence as "no forcing requirement" — convergence falls back
+ * to the no-new-decisions / stop-signal detectors). Returning [] when
+ * the row exists but lists no segments is also legal.
+ */
+export function extractForcingQuestions(stage) {
+    let checklist;
+    try {
+        checklist = stageSchema(stage).executionModel.checklist;
+    }
+    catch {
+        return [];
+    }
+    for (const row of checklist) {
+        const parsed = parseForcingQuestionsRow(row, `stage=${stage}`);
+        if (parsed === null)
+            continue;
+        return parsed;
+    }
+    return [];
+}
+/**
+ * Detect whether a Q&A Log row carries an explicit `[topic:<id>]` tag
+ * for the requested forcing-topic id. Matching is case-insensitive on
+ * the id, ASCII-only on the tag boundary. NO keyword fallback: the user
+ * must stamp the tag in any cell of the row.
+ */
+function isTopicAddressed(id, rows) {
+    const needle = id.toLowerCase();
+    const tagPattern = /\[topic:\s*([A-Za-z0-9][A-Za-z0-9-]*)\s*\]/giu;
+    for (const row of rows) {
+        const haystack = row.join(" | ");
+        tagPattern.lastIndex = 0;
+        let match;
+        while ((match = tagPattern.exec(haystack)) !== null) {
+            const candidate = (match[1] ?? "").toLowerCase();
+            if (candidate === needle)
+                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)).map((entry) => (typeof entry === "string" ? { id: entry, topic: entry } : entry));
+    const forcingCovered = [];
+    const forcingPending = [];
+    for (const topic of forcingTopics) {
+        if (isTopicAddressed(topic.id, rows))
+            forcingCovered.push(topic.id);
+        else
+            forcingPending.push(topic.id);
+    }
+    const noNewDecisions = lastTwoRowsAllNoDecision(substantiveRows);
+    const allForcingCovered = forcingTopics.length > 0 ? forcingPending.length === 0 : count >= 1;
+    const ok = allForcingCovered || noNewDecisions || hasStopSignal;
+    const pendingIdsBracket = forcingPending.length > 0
+        ? `[${forcingPending.join(", ")}]`
+        : "[none]";
     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 (allForcingCovered) {
+            details = `Q&A Log converged: stage exposes no forcing-questions row and ${count} substantive entry recorded.`;
         }
-        else if (hasStopSignal) {
-            details = `Q&A Log has ${count} substantive entries with an explicit user stop-signal row recorded (floor: ${min}).`;
+        else if (noNewDecisions) {
+            const remaining = forcingPending.length > 0
+                ? ` ${forcingPending.length} forcing topic IDs still pending: ${pendingIdsBracket} (Ralph-Loop convergence overrode coverage).`
+                : " 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. Forcing topic IDs pending: ${pendingIdsBracket}.`;
     }
     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). Forcing topic IDs pending: ${pendingIdsBracket}. Tag each Q&A row with \`[topic:<id>]\` to mark coverage, append a no-new-decisions pair, or record an explicit user stop-signal row.`;
     }
+    // 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 +848,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 +1672,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) every forcing-question topic id is tagged \`[topic:<id>]\` on at least one \`## Q&A Log\` row, (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 24 (v6.0.0) made the topic tag MANDATORY (no English keyword fallback) so the gate works in any natural language.
 - **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.
 
@@ -124,24 +127,38 @@ How to use the columns:
 - \`skipped (already covered: turn N)\` — answered implicitly by an earlier reply; cite the turn.
 - \`waived (user override)\` — user explicitly waived this question.
 
-Stage forcing question lists:
+### Topic tagging (MANDATORY for forcing-question rows)
+
+Each forcing question has a stable topic id (kebab-case ASCII, e.g. \`pain\`, \`do-nothing\`, \`data-flow\`). Tag the matching Q&A Log row's \`Decision impact\` cell with \`[topic:<id>]\` so the linter can verify coverage in any natural language. This is a **HARD requirement** in Wave 24 (v6.0.0): the linter no longer keyword-matches English question prose, so an un-tagged row does NOT count toward coverage even if the answer fully addresses the topic.
+
+RU example (after asking \`pain\` in Russian):
+
+\`\`\`
+| Turn | Question | User answer (1-line) | Decision impact |
+|---|---|---|---|
+| 1 | Какую боль мы решаем? | Регистрация занимает 30 минут. | scope-shaping [topic:pain] |
+\`\`\`
+
+Multiple tags in one row are allowed when one answer covers several topics: \`[topic:pain] [topic:do-nothing]\`. Stop-signal rows do NOT need a tag.
+
+Stage forcing question lists (id → topic):
 
 - **Brainstorm**:
-  - What pain are we solving?
-  - What is the most direct path?
-  - What happens if we do nothing?
-  - Who is the operator/user impacted first?
-  - What are non-negotiable no-go boundaries?
+  - \`pain\` — What pain are we solving?
+  - \`direct-path\` — What is the most direct path?
+  - \`do-nothing\` — What happens if we do nothing?
+  - \`operator\` — Who is the operator/user impacted first?
+  - \`no-go\` — What are non-negotiable no-go boundaries?
 - **Scope**:
-  - What is definitely in and definitely out?
-  - Which decisions are already locked upstream?
-  - What is the rollback path if this fails?
-  - What are the top failure modes we must design for?
+  - \`in-out\` — What is definitely in and definitely out?
+  - \`locked-upstream\` — Which decisions are already locked upstream?
+  - \`rollback\` — What is the rollback path if this fails?
+  - \`failure-modes\` — What are the top failure modes we must design for?
 - **Design**:
-  - What is the data flow end-to-end?
-  - Where are the seams/interfaces and ownership boundaries?
-  - Which invariants must always hold?
-  - What will we explicitly NOT refactor now?
+  - \`data-flow\` — What is the data flow end-to-end?
+  - \`seams\` — Where are the seams/interfaces and ownership boundaries?
+  - \`invariants\` — Which invariants must always hold?
+  - \`not-refactor\` — What will we explicitly NOT refactor now?
 
 ## One-Way Override (Irreversible Decisions)
 

package/dist/content/skills.js

@@ -360,10 +360,16 @@ function mergedAntiPatterns(philosophy, execution) {
 }
 function completionParametersBlock(schema, track) {
     const gateList = schema.executionModel.requiredGates.map((g) => `\`${g.id}\``).join(", ");
-    const mandatoryAgents = schema.reviewLens.mandatoryDelegations;
-    const mandatory = schema.reviewLens.mandatoryDelegations.length > 0
-        ? schema.reviewLens.mandatoryDelegations.map((a) => `\`${a}\``).join(", ")
-        : "none";
+    // Wave 24 (v6.0.0): mandatory agents are dropped on `quick` track. Surface
+    // the empty list so the rendered SKILL.md doesn't tell quick-track runs to
+    // dispatch agents the linter is going to skip.
+    const trackAwareMandatoryAgents = track === "quick" ? [] : schema.reviewLens.mandatoryDelegations;
+    const mandatoryAgents = trackAwareMandatoryAgents;
+    const mandatory = trackAwareMandatoryAgents.length > 0
+        ? trackAwareMandatoryAgents.map((a) => `\`${a}\``).join(", ")
+        : track === "quick" && schema.reviewLens.mandatoryDelegations.length > 0
+            ? "none (skipped: quick track — Wave 24)"
+            : "none";
     const resolvedNextStage = nextStageForTrack(schema.stage, track);
     const nextStage = resolvedNextStage ?? "done";
     const nextDescription = nextStage === "done"

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

@@ -55,6 +55,35 @@ export declare function validateSkillEnvelope(value: unknown): SkillEnvelopeVali
 export declare function parseSkillEnvelope(raw: string): SkillEnvelope | null;
 /** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
 export declare function mandatoryDelegationsForStage(stage: FlowStage, complexityTier?: StageComplexityTier): string[];
+/**
+ * Wave 24 (v6.0.0) — track-aware mandatory delegation lookup.
+ *
+ * Returns `[]` (skip the gate entirely) when the run is on a small-fix
+ * track or classified as a software bugfix:
+ *
+ *   - `track === "quick"` — the quick track is for trivial single-purpose
+ *     fixes (landing-page copy, doc edits, config tweaks). Mandatory
+ *     subagent dispatch is theatre on that surface area.
+ *   - `taskClass === "software-bugfix"` — bugfixes carry a RED-first
+ *     repro contract; the test author + reviewer in the tdd/review
+ *     stages already cover the safety surface, so mandatory upstream
+ *     delegation only burns tokens.
+ *
+ * Otherwise returns the registered mandatory list for the stage at the
+ * given tier. Callers (gate-evidence, advance-stage validator,
+ * subagents.ts table generator) MUST go through this helper instead of
+ * `mandatoryDelegationsForStage` so the track-aware drop applies
+ * uniformly.
+ *
+ * NOTE: the user query also calls this `lite/quick`. There is no `lite`
+ * FlowTrack — the closest concept in cclaw is the `quick` track plus the
+ * brainstorm `lightweight` complexity tier. We key on the FlowTrack
+ * because the run-level decision is what matters at gate time;
+ * complexity tier is a per-stage knob that doesn't survive the dispatch
+ * boundary.
+ */
+export type MandatoryDelegationTaskClass = "software-standard" | "software-trivial" | "software-bugfix";
+export declare function mandatoryAgentsFor(stage: FlowStage, track: FlowTrack, taskClass?: MandatoryDelegationTaskClass | null, complexityTier?: StageComplexityTier): string[];
 export declare function stageSchema(stage: FlowStage, track?: FlowTrack): StageSchema;
 export declare function orderedStageSchemas(track?: FlowTrack): StageSchema[];
 export declare function stageGateIds(stage: FlowStage, track?: FlowTrack): string[];

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: [
         {
@@ -801,6 +811,13 @@ export function mandatoryDelegationsForStage(stage, complexityTier = "standard")
         .find((row) => row.stage === stage);
     return summary ? summary.mandatoryAgents : [];
 }
+export function mandatoryAgentsFor(stage, track, taskClass, complexityTier = "standard") {
+    if (track === "quick")
+        return [];
+    if (taskClass === "software-bugfix")
+        return [];
+    return mandatoryDelegationsForStage(stage, complexityTier);
+}
 export function stageSchema(stage, track = "standard") {
     const rawInput = stage === "tdd" ? tddStageForTrack(track) : STAGE_SCHEMA_MAP[stage];
     const base = normalizeStageSchemaInput(rawInput);

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"