cclaw-cli 5.0.0 → 6.0.0

package/dist/artifact-linter/brainstorm.js

@@ -24,7 +24,7 @@ export async function lintBrainstormStage(ctx) {
         findings.push({
             section: "qa_log_unconverged",
             required: !floor.skipQuestionsAdvisory,
-            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
             found: floor.ok,
             details: floor.details
         });

package/dist/artifact-linter/design.js

@@ -224,7 +224,7 @@ export async function lintDesignStage(ctx) {
         findings.push({
             section: "qa_log_unconverged",
             required: !floor.skipQuestionsAdvisory,
-            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
             found: floor.ok,
             details: floor.details
         });

package/dist/artifact-linter/scope.js

@@ -25,7 +25,7 @@ export async function lintScopeStage(ctx) {
         findings.push({
             section: "qa_log_unconverged",
             required: !floor.skipQuestionsAdvisory,
-            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
             found: floor.ok,
             details: floor.details
         });

package/dist/artifact-linter/shared.d.ts

@@ -5,6 +5,20 @@ import { type FlowStage, type FlowTrack } from "../types.js";
  * convergence floor is enforced.
  */
 export declare const ELICITATION_STAGES: ReadonlySet<FlowStage>;
+/**
+ * Wave 24 (v6.0.0) — language-neutral forcing-question topic descriptor.
+ *
+ * Each forcing-question row in a stage's checklist now declares topics as
+ * `id: human-readable label` pairs (e.g. `pain: what pain are we solving`).
+ * The `id` (kebab-case ASCII) is the machine-key authors stamp on Q&A Log
+ * rows via `[topic:<id>]` so the linter can verify coverage in ANY natural
+ * language (RU/EN/UA/etc.). Wave 23's English keyword fallback was removed
+ * because it silently mis-reported convergence on RU/UA Q&A.
+ */
+export interface ForcingQuestionTopic {
+    id: string;
+    topic: string;
+}
 export interface QaLogFloorOptions {
     /**
      * When true, downgrades the finding to advisory (`required: false`).
@@ -12,11 +26,12 @@ export interface QaLogFloorOptions {
      */
     skipQuestions?: boolean;
     /**
-     * Optional pre-extracted forcing-question topics. When omitted, the
-     * evaluator calls `extractForcingQuestions(stage)` which scans the
-     * stage's checklist row.
+     * Optional pre-extracted forcing-question topic descriptors. When
+     * omitted, the evaluator calls `extractForcingQuestions(stage)` which
+     * scans the stage's checklist row. Strings are accepted as topic IDs
+     * (label = id) for callers that build their own list.
      */
-    forcingQuestions?: string[];
+    forcingQuestions?: ReadonlyArray<ForcingQuestionTopic | string>;
 }
 export interface QaLogFloorResult {
     /** Whether convergence is satisfied (passes the gate). */
@@ -53,17 +68,30 @@ export interface QaLogFloorResult {
     details: string;
 }
 /**
- * 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`).
+ * 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 declare function parseForcingQuestionsRow(row: string, context?: string): ForcingQuestionTopic[] | null;
+/**
+ * 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.
  *
  * 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).
+ * 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 declare function extractForcingQuestions(stage: FlowStage): string[];
+export declare function extractForcingQuestions(stage: FlowStage): ForcingQuestionTopic[];
 /**
  * Evaluate the Q&A Log convergence floor for a brainstorm / scope /
  * design artifact. Returns ok=true when convergence is reached or any

package/dist/artifact-linter/shared.js

@@ -86,15 +86,70 @@ function detectStopSignal(rows) {
     return false;
 }
 /**
- * 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`).
+ * 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.
  *
  * 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).
+ * 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;
@@ -105,61 +160,29 @@ export function extractForcingQuestions(stage) {
         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)
+        const parsed = parseForcingQuestionsRow(row, `stage=${stage}`);
+        if (parsed === null)
             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 parsed;
     }
     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.
+ * 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 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);
+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(" | ").toLowerCase();
-        let hits = 0;
-        for (const keyword of keywords) {
-            if (haystack.includes(keyword))
-                hits += 1;
-            if (hits >= minHits)
+        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;
         }
     }
@@ -210,18 +233,21 @@ export function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
     const count = substantiveRows.length;
     const hasStopSignal = detectStopSignal(rows);
     const skipQuestionsAdvisory = options.skipQuestions === true;
-    const forcingTopics = options.forcingQuestions ?? extractForcingQuestions(stage);
+    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, rows))
-            forcingCovered.push(topic);
+        if (isTopicAddressed(topic.id, rows))
+            forcingCovered.push(topic.id);
         else
-            forcingPending.push(topic);
+            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 (allForcingCovered && forcingTopics.length > 0) {
@@ -232,7 +258,7 @@ export function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
         }
         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).`
+                ? ` ${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}`;
         }
@@ -241,10 +267,10 @@ export function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
         }
     }
     else if (skipQuestionsAdvisory) {
-        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)"}.`;
+        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 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.`;
+        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.

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.
-- **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.
+- **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.
 
@@ -127,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

@@ -811,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/brainstorm.js

@@ -36,9 +36,9 @@ 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 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.",
+            "**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 **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:pain]`). Continue until every forcing-question topic id is tagged on a row 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.",
+            "**Brainstorm forcing questions (must be covered or explicitly waived)** — `pain: what pain are we solving`; `direct-path: what is the direct path`; `do-nothing: what happens if we do nothing`; `operator: who is the first operator/user affected`; `no-go: what no-go boundaries are non-negotiable`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:pain]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage.",
             "**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.",
             "**Write the Problem Decision Record** — pick a free-form `Frame type` label that names how this work is framed (examples: product, technical-maintenance, research-spike, ops-incident, infrastructure), then fill the universal Framing fields: affected user/role/operator, current state/failure mode/opportunity, desired observable outcome, evidence/signal, why now, do-nothing consequence, and non-goals.",
             "**Premise check (one pass)** — answer the three gstack-style questions in the artifact body: *Right problem? Direct path? What if we do nothing?* Take a position; do not hedge.",

package/dist/content/stages/design.js

@@ -41,8 +41,8 @@ export const DESIGN = {
     },
     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 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.",
+            "**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 **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:data-flow]`). Continue until every forcing-question topic id is tagged on a row 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)** — `data-flow: what is the end-to-end data flow`; `seams: where are seams/ownership boundaries`; `invariants: which invariants must hold`; `not-refactor: what will explicitly NOT be refactored now`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:data-flow]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage.",
             "**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.",

package/dist/content/stages/scope.js

@@ -46,8 +46,8 @@ export const SCOPE = {
     },
     executionModel: {
         checklist: [
-            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the scope 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 propose the scope contract draft, recommend a mode, or dispatch any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
-            "**Scope forcing questions (must be covered or explicitly waived)** — what is definitely in/out, which upstream decisions are locked, and what rollback path protects users if scope assumptions fail.",
+            "**ADAPTIVE ELICITATION COMES FIRST (no exceptions, no subagent dispatch before).** Load `.cclaw/skills/adaptive-elicitation/SKILL.md`. Walk the scope 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 **and stamp the row's `Decision impact` cell with the matching `[topic:<id>]` tag** (e.g. `[topic:in-out]`). Continue until every forcing-question topic id is tagged on a row 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 propose the scope contract draft, recommend a mode, or dispatch any delegations. The linter `qa_log_unconverged` rule will block `stage-complete` if convergence is not reached.",
+            "**Scope forcing questions (must be covered or explicitly waived)** — `in-out: what is definitely in/out`; `locked-upstream: which upstream decisions are locked`; `rollback: what rollback path protects users if scope assumptions fail`; `failure-modes: what are the top failure modes we must design for`. Tag the matching `## Q&A Log` row's `Decision impact` cell with `[topic:<id>]` (e.g. `[topic:in-out]`) so the linter can verify coverage in any natural language. Tags are MANDATORY for forcing-question rows; un-tagged rows do NOT count toward coverage.",
             "**Scope contract first** — read brainstorm handoff, name upstream decisions used, explicit drift, confidence, unresolved questions, and next-stage risk hints; draft the in-scope/out-of-scope/deferred/discretion contract before any design choice.",
             "**Premise carry-forward (do NOT re-author)** — brainstorm OWNS the premise check (right problem / direct path / what if nothing). Cite brainstorm's `## Premise Check` section in `## Upstream Handoff > Decisions carried forward`. Add a row to `## Premise Drift` only when the scope-stage Q&A surfaced NEW evidence that materially changes the brainstorm answer (e.g. new constraint, new user signal). Otherwise mark `Premise Drift: None` — do not duplicate the brainstorm premise table.",
             "**Conditional 10-star boundary** — for deep/high-risk/product-strategy work, show what would make the product meaningfully better, then explicitly choose what ships now, what is deferred, and what is excluded without vague `later/for now` placeholders. Skip this for straightforward repair work and record `not needed: compact scope`.",

package/dist/content/subagents.js

@@ -16,7 +16,9 @@ function automaticStageDelegationTable() {
     }).join("\n");
     return `| Stage | Mandatory agents | Proactive agents |
 |---|---|---|
-${rows}`;
+${rows}
+
+> **Track-aware skip (Wave 24, v6.0.0):** mandatory agents are skipped entirely when \`track === "quick"\` OR \`taskClass === "software-bugfix"\`. Use \`mandatoryAgentsFor(stage, track, taskClass)\` from \`src/content/stage-schema.ts\` for the authoritative list at runtime. Proactive agents stay enforced because they fire only on triggers (high blast radius, security-sensitive paths, etc.), not on every run.`;
 }
 function stageSummary(stage) {
     return stageDelegationSummary("standard").find((row) => row.stage === stage)

package/dist/content/templates.d.ts

@@ -6,6 +6,6 @@ export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n-
  * loading skills. Three hard rules cover the most common Wave 22 regressions
  * (premature draft, premature subagent dispatch, command-line echo to chat).
  */
-export declare const CURSOR_GUIDELINES_RULE_MDC = "---\ndescription: cclaw zero-install behavior baseline (always-on)\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-guidelines-rule -->\n\n# Cclaw Baseline Guidelines\n\nThese three rules apply to every Cursor agent session in this project,\nregardless of whether stage skills loaded.\n\n## 1. Q&A floor before drafting (brainstorm/scope/design)\n\nBefore drafting any `.cclaw/artifacts/01-brainstorm-*.md`,\n`02-scope-*.md`, or `03-design-*.md`, verify that the artifact's\n`## Q&A Log` table demonstrates Ralph-Loop convergence: forcing-question\ntopics are addressed (see the stage's forcing-questions checklist row),\nthe last 2 turns produce no new decision-changing impact, OR an explicit\nuser stop-signal row is recorded. Walk the stage forcing questions one at\na time via the `AskQuestion` tool. If you find yourself proposing a\ndraft after 1-2 questions while forcing topics remain unaddressed, STOP\nand continue the loop.\n\nThe `qa_log_unconverged` linter rule will block `stage-complete` when\nconvergence has not been reached.\n\n## 2. Mandatory subagents run after Q&A approval\n\nFor brainstorm / scope / design, mandatory subagents (\n`product-discovery`, `critic`, `planner`, `architect`,\n`test-author`) run **only AFTER the user approves the elicitation\noutcome**, never before the Q&A loop converges. Dispatching them early\npreempts the user dialogue and violates the elicitation contract \u2014 the\nlinter will block stage-complete.\n\nSee each stage's \"Run Phase: post-elicitation\" rows in the materialized\nAutomatic Subagent Dispatch table.\n\n## 3. Never echo cclaw command lines to chat\n\nThe user does not run cclaw helpers (`node .cclaw/hooks/...`) manually.\nNEVER paste full command lines, `--evidence-json '{...}'` payloads,\n`--waive-delegation=...`, or shell hash commands (`shasum`,\n`sha256sum`, `Get-FileHash`, `certutil`, etc.) into chat. Run the\nhelper via the tool layer and report only the resulting summary. On\nfailure, report a compact human-readable summary plus the helper JSON in\na single fenced `json` block.\n";
-export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n## Activation Rule\n\nBefore responding to coding work:\n1. Read `.cclaw/state/flow-state.json`.\n2. Start with `/cc` or continue with `/cc`.\n3. If no software-stage flow applies, respond normally.\n\n## Stage Order\n\n`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship`\n\nTrack-specific skips are allowed only when `flow-state.track` + `skippedStages` explicitly say so.\n\n## Task Classification\n\n| Class | Route |\n|---|---|\n| non-trivial software work | `/cc <idea>` |\n| trivial software fix | `/cc <idea>` (quick track) |\n| bugfix with repro | `/cc <idea>` and enforce RED-first in tdd |\n| pure question / non-software | direct answer (no stage flow) |\n\n## Command Surface\n\n- `/cc` = entry and resume.\n- `/cc` = only progression path.\n- Knowledge capture and recall use the `learnings` skill when requested.\n\n## Verification Discipline\n\n- No completion claim without fresh command evidence in this turn.\n- Do not mark gates passed from memory.\n- Keep evidence in `.cclaw/artifacts/`; archive through closeout via `/cc` or cancel early via `node .cclaw/hooks/cancel-run.mjs`.\n\n## Delegation And Approvals\n\n- Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.\n- **For brainstorm / scope / design stages**: ask user input continuously via adaptive elicitation (one question per turn through the harness-native question tool \u2014 `AskQuestion` in Cursor). Walk the stage forcing-questions list one-by-one. Do NOT batch and do NOT defer to a single approval gate at the end. The `qa_log_unconverged` linter rule will block `stage-complete` when convergence is not reached (forcing topics unaddressed AND last 2 turns still produce decision-changing rows AND no stop-signal).\n- **For other stages** (spec/plan/tdd/build/review/ship): ask user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization), not for routine progress updates.\n- If you find yourself proposing a draft after 1-2 questions in brainstorm/scope/design, STOP \u2014 go back to the forcing-questions list and continue.\n- Mandatory subagents in brainstorm/scope/design run only AFTER the user approves the elicitation outcome (see each stage's \"Run Phase: post-elicitation\" rows). Dispatching them before the Q&A loop converges violates the contract.\n- Never echo cclaw command lines (`node .cclaw/hooks/...`, `--evidence-json '{...}'`) to chat \u2014 the user does not run cclaw manually. Run helpers via the tool layer; report only the resulting summary.\n- If harness capabilities are partial, record waiver reasons in delegation logs.\n\n## Routing Source Of Truth\n\n- Primary router: `.cclaw/skills/using-cclaw/SKILL.md`.\n- Stage behavior: current stage skill plus `.cclaw/state/flow-state.json`.\n- Preamble budget: keep role/status announcements brief and avoid repeating\n  them unless the stage or role changes.\n";
+export declare const CURSOR_GUIDELINES_RULE_MDC = "---\ndescription: cclaw zero-install behavior baseline (always-on)\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-guidelines-rule -->\n\n# Cclaw Baseline Guidelines\n\nThese three rules apply to every Cursor agent session in this project,\nregardless of whether stage skills loaded.\n\n## 1. Q&A floor before drafting (brainstorm/scope/design)\n\nBefore drafting any `.cclaw/artifacts/01-brainstorm-*.md`,\n`02-scope-*.md`, or `03-design-*.md`, verify that the artifact's\n`## Q&A Log` table demonstrates Ralph-Loop convergence: every\nforcing-question topic id is tagged `[topic:<id>]` on at least one row\n(see the stage's forcing-questions checklist for the id list), the last\n2 turns produce no new decision-changing impact, OR an explicit user\nstop-signal row is recorded. Walk the stage forcing questions one at a\ntime via the `AskQuestion` tool. If you find yourself proposing a\ndraft after 1-2 questions while forcing topic ids remain untagged, STOP\nand continue the loop.\n\nThe `qa_log_unconverged` linter rule will block `stage-complete` when\nconvergence has not been reached. Wave 24 (v6.0.0) made `[topic:<id>]`\ntagging mandatory; the English keyword fallback was removed because it\nmis-reported convergence on RU/UA Q&A logs.\n\n## 2. Mandatory subagents run after Q&A approval\n\nFor brainstorm / scope / design, mandatory subagents (\n`product-discovery`, `critic`, `planner`, `architect`,\n`test-author`) run **only AFTER the user approves the elicitation\noutcome**, never before the Q&A loop converges. Dispatching them early\npreempts the user dialogue and violates the elicitation contract \u2014 the\nlinter will block stage-complete.\n\nSee each stage's \"Run Phase: post-elicitation\" rows in the materialized\nAutomatic Subagent Dispatch table.\n\n## 3. Never echo cclaw command lines to chat\n\nThe user does not run cclaw helpers (`node .cclaw/hooks/...`) manually.\nNEVER paste full command lines, `--evidence-json '{...}'` payloads,\n`--waive-delegation=...`, or shell hash commands (`shasum`,\n`sha256sum`, `Get-FileHash`, `certutil`, etc.) into chat. Run the\nhelper via the tool layer and report only the resulting summary. On\nfailure, report a compact human-readable summary plus the helper JSON in\na single fenced `json` block.\n";
+export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n## Activation Rule\n\nBefore responding to coding work:\n1. Read `.cclaw/state/flow-state.json`.\n2. Start with `/cc` or continue with `/cc`.\n3. If no software-stage flow applies, respond normally.\n\n## Stage Order\n\n`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship`\n\nTrack-specific skips are allowed only when `flow-state.track` + `skippedStages` explicitly say so.\n\n## Task Classification\n\n| Class | Route |\n|---|---|\n| non-trivial software work | `/cc <idea>` |\n| trivial software fix | `/cc <idea>` (quick track) |\n| bugfix with repro | `/cc <idea>` and enforce RED-first in tdd |\n| pure question / non-software | direct answer (no stage flow) |\n\n## Command Surface\n\n- `/cc` = entry and resume.\n- `/cc` = only progression path.\n- Knowledge capture and recall use the `learnings` skill when requested.\n\n## Verification Discipline\n\n- No completion claim without fresh command evidence in this turn.\n- Do not mark gates passed from memory.\n- Keep evidence in `.cclaw/artifacts/`; archive through closeout via `/cc` or cancel early via `node .cclaw/hooks/cancel-run.mjs`.\n\n## Delegation And Approvals\n\n- Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.\n- **For brainstorm / scope / design stages**: ask user input continuously via adaptive elicitation (one question per turn through the harness-native question tool \u2014 `AskQuestion` in Cursor). Walk the stage forcing-questions list one-by-one. **Tag each Q&A Log row's `Decision impact` cell with `[topic:<id>]`** (the id is given in the stage's forcing-questions checklist) so the linter can verify coverage in any natural language. Do NOT batch and do NOT defer to a single approval gate at the end. The `qa_log_unconverged` linter rule will block `stage-complete` when convergence is not reached (forcing topic ids untagged AND last 2 turns still produce decision-changing rows AND no stop-signal).\n- **For other stages** (spec/plan/tdd/build/review/ship): ask user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization), not for routine progress updates.\n- If you find yourself proposing a draft after 1-2 questions in brainstorm/scope/design, STOP \u2014 go back to the forcing-questions list and continue.\n- Mandatory subagents in brainstorm/scope/design run only AFTER the user approves the elicitation outcome (see each stage's \"Run Phase: post-elicitation\" rows). Dispatching them before the Q&A loop converges violates the contract.\n- Never echo cclaw command lines (`node .cclaw/hooks/...`, `--evidence-json '{...}'`) to chat \u2014 the user does not run cclaw manually. Run helpers via the tool layer; report only the resulting summary.\n- If harness capabilities are partial, record waiver reasons in delegation logs.\n\n## Routing Source Of Truth\n\n- Primary router: `.cclaw/skills/using-cclaw/SKILL.md`.\n- Stage behavior: current stage skill plus `.cclaw/state/flow-state.json`.\n- Preamble budget: keep role/status announcements brief and avoid repeating\n  them unless the stage or role changes.\n";
 export declare function buildRulesJson(): Record<string, unknown>;

package/dist/content/templates.js

@@ -86,9 +86,10 @@ export const ARTIFACT_TEMPLATES = {
 ## Q&A Log
 | Turn | Question | User answer (1-line) | Decision impact |
 |---|---|---|---|
-| 1 |  |  |  |
+| 1 |  |  | scope-shaping [topic:pain] |
 
 > Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+> **Topic tag is MANDATORY for forcing-question rows.** Stamp \`[topic:<id>]\` in the \`Decision impact\` cell so the linter can verify coverage in any natural language (RU/EN/UA/etc.). Brainstorm IDs: \`pain\`, \`direct-path\`, \`do-nothing\`, \`operator\`, \`no-go\`. Multiple tags allowed when one answer covers several topics. Stop-signal rows do NOT need a tag. Wave 24 (v6.0.0) removed the English keyword fallback.
 
 ## Approach Tier
 - Tier: lite | standard | deep
@@ -209,9 +210,10 @@ ${MARKDOWN_CODE_FENCE}
 ## Q&A Log
 | Turn | Question | User answer (1-line) | Decision impact |
 |---|---|---|---|
-| 1 |  |  |  |
+| 1 |  |  | scope-shaping [topic:in-out] |
 
 > Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+> **Topic tag is MANDATORY for forcing-question rows.** Stamp \`[topic:<id>]\` in the \`Decision impact\` cell so the linter can verify coverage in any natural language (RU/EN/UA/etc.). Scope IDs: \`in-out\`, \`locked-upstream\`, \`rollback\`, \`failure-modes\`. Multiple tags allowed when one answer covers several topics. Stop-signal rows do NOT need a tag. Wave 24 (v6.0.0) removed the English keyword fallback.
 
 ## Pre-Scope System Audit
 | Check | Command | Findings |
@@ -447,9 +449,10 @@ ${MARKDOWN_CODE_FENCE}
 ## Q&A Log
 | Turn | Question | User answer (1-line) | Decision impact |
 |---|---|---|---|
-| 1 |  |  |  |
+| 1 |  |  | architecture-shaping [topic:data-flow] |
 
 > Append-only by turn. Add one row after each user answer; do not rewrite prior rows.
+> **Topic tag is MANDATORY for forcing-question rows.** Stamp \`[topic:<id>]\` in the \`Decision impact\` cell so the linter can verify coverage in any natural language (RU/EN/UA/etc.). Design IDs: \`data-flow\`, \`seams\`, \`invariants\`, \`not-refactor\`. Multiple tags allowed when one answer covers several topics. Stop-signal rows do NOT need a tag. Wave 24 (v6.0.0) removed the English keyword fallback.
 
 ## Codebase Investigation
 | File | Current responsibility | Patterns discovered | Existing fit / reuse candidate |
@@ -1484,16 +1487,19 @@ regardless of whether stage skills loaded.
 
 Before drafting any \`.cclaw/artifacts/01-brainstorm-*.md\`,
 \`02-scope-*.md\`, or \`03-design-*.md\`, verify that the artifact's
-\`## Q&A Log\` table demonstrates Ralph-Loop convergence: forcing-question
-topics are addressed (see the stage's forcing-questions checklist row),
-the last 2 turns produce no new decision-changing impact, OR an explicit
-user stop-signal row is recorded. Walk the stage forcing questions one at
-a time via the \`AskQuestion\` tool. If you find yourself proposing a
-draft after 1-2 questions while forcing topics remain unaddressed, STOP
+\`## Q&A Log\` table demonstrates Ralph-Loop convergence: every
+forcing-question topic id is tagged \`[topic:<id>]\` on at least one row
+(see the stage's forcing-questions checklist for the id list), the last
+2 turns produce no new decision-changing impact, OR an explicit user
+stop-signal row is recorded. Walk the stage forcing questions one at a
+time via the \`AskQuestion\` tool. If you find yourself proposing a
+draft after 1-2 questions while forcing topic ids remain untagged, STOP
 and continue the loop.
 
 The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when
-convergence has not been reached.
+convergence has not been reached. Wave 24 (v6.0.0) made \`[topic:<id>]\`
+tagging mandatory; the English keyword fallback was removed because it
+mis-reported convergence on RU/UA Q&A logs.
 
 ## 2. Mandatory subagents run after Q&A approval
 
@@ -1565,7 +1571,7 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 ## Delegation And Approvals
 
 - Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.
-- **For brainstorm / scope / design stages**: ask user input continuously via adaptive elicitation (one question per turn through the harness-native question tool — \`AskQuestion\` in Cursor). Walk the stage forcing-questions list one-by-one. Do NOT batch and do NOT defer to a single approval gate at the end. The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence is not reached (forcing topics unaddressed AND last 2 turns still produce decision-changing rows AND no stop-signal).
+- **For brainstorm / scope / design stages**: ask user input continuously via adaptive elicitation (one question per turn through the harness-native question tool — \`AskQuestion\` in Cursor). Walk the stage forcing-questions list one-by-one. **Tag each Q&A Log row's \`Decision impact\` cell with \`[topic:<id>]\`** (the id is given in the stage's forcing-questions checklist) so the linter can verify coverage in any natural language. Do NOT batch and do NOT defer to a single approval gate at the end. The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence is not reached (forcing topic ids untagged AND last 2 turns still produce decision-changing rows AND no stop-signal).
 - **For other stages** (spec/plan/tdd/build/review/ship): ask user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization), not for routine progress updates.
 - If you find yourself proposing a draft after 1-2 questions in brainstorm/scope/design, STOP — go back to the forcing-questions list and continue.
 - Mandatory subagents in brainstorm/scope/design run only AFTER the user approves the elicitation outcome (see each stage's "Run Phase: post-elicitation" rows). Dispatching them before the Q&A loop converges violates the contract.

package/dist/delegation.d.ts

@@ -1,4 +1,5 @@
 import { type SubagentFallback } from "./harness-adapters.js";
+import { type MandatoryDelegationTaskClass } from "./content/stage-schema.js";
 import type { FlowStage } from "./types.js";
 export type DelegationMode = "mandatory" | "proactive";
 export type DelegationStatus = "scheduled" | "launched" | "acknowledged" | "completed" | "failed" | "waived" | "stale";
@@ -143,6 +144,13 @@ export declare function appendDelegation(projectRoot: string, entry: DelegationE
 export declare function expectedFulfillmentMode(fallbacks: SubagentFallback[]): DelegationFulfillmentMode;
 export declare function checkMandatoryDelegations(projectRoot: string, stage: FlowStage, options?: {
     repairFeatureSystem?: boolean;
+    /**
+     * Optional task class for the active run. When set to
+     * `"software-bugfix"`, the mandatory delegation gate is skipped
+     * entirely (Wave 24). Callers that don't classify the run leave
+     * this undefined and rely on the track-based skip.
+     */
+    taskClass?: MandatoryDelegationTaskClass | null;
 }): Promise<{
     satisfied: boolean;
     missing: string[];
@@ -160,4 +168,12 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
     staleWorkers: string[];
     /** Expected fulfillment mode for the active harness set. */
     expectedMode: DelegationFulfillmentMode;
+    /**
+     * Wave 24 (v6.0.0): true when `mandatoryAgentsFor` returned [] for
+     * this (track, taskClass) combination — i.e. the gate was skipped
+     * entirely on quick track or software-bugfix runs. The skip is also
+     * recorded as a `mandatory_delegations_skipped_by_track` event in
+     * `delegation-events.jsonl` for audit traceability.
+     */
+    skippedByTrack: boolean;
 }>;

package/dist/delegation.js

@@ -7,7 +7,7 @@ import { readConfig } from "./config.js";
 import { exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
-import { stageSchema } from "./content/stage-schema.js";
+import { mandatoryAgentsFor, stageSchema } from "./content/stage-schema.js";
 const execFileAsync = promisify(execFile);
 const TERMINAL_DELEGATION_STATUSES = new Set(["completed", "failed", "waived", "stale"]);
 export const DELEGATION_DISPATCH_SURFACES = [
@@ -320,6 +320,21 @@ export async function readDelegationLedger(projectRoot) {
         return { runId: activeRunId, entries: [] };
     }
 }
+/**
+ * Wave 24 (v6.0.0) audit-only event types that live in
+ * `delegation-events.jsonl` but do NOT carry a delegation lifecycle
+ * payload (no agent/spanId). The parser must accept them so they
+ * don't show up as corrupt lines.
+ */
+const NON_DELEGATION_AUDIT_EVENTS = new Set([
+    "mandatory_delegations_skipped_by_track"
+]);
+function isAuditEventLine(parsed) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const evt = parsed.event;
+    return typeof evt === "string" && NON_DELEGATION_AUDIT_EVENTS.has(evt);
+}
 export async function readDelegationEvents(projectRoot) {
     const filePath = delegationEventsPath(projectRoot);
     if (!(await exists(filePath))) {
@@ -338,6 +353,11 @@ export async function readDelegationEvents(projectRoot) {
             if (isDelegationEvent(parsed)) {
                 events.push(parsed);
             }
+            else if (isAuditEventLine(parsed)) {
+                // Wave 24 audit-only row (e.g. mandatory_delegations_skipped_by_track).
+                // Not a delegation lifecycle event but valid audit content.
+                continue;
+            }
             else {
                 corruptLines.push(index + 1);
             }
@@ -451,7 +471,17 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
     const flowState = await readFlowState(projectRoot, {
         repairFeatureSystem: options.repairFeatureSystem
     });
-    const mandatory = stageSchema(stage, flowState.track).mandatoryDelegations;
+    const mandatory = mandatoryAgentsFor(stage, flowState.track, options.taskClass ?? null);
+    const skippedByTrack = mandatory.length === 0 &&
+        stageSchema(stage, flowState.track).mandatoryDelegations.length > 0;
+    if (skippedByTrack) {
+        await recordMandatorySkippedByTrack(projectRoot, {
+            stage,
+            track: flowState.track,
+            taskClass: options.taskClass ?? null,
+            runId: flowState.activeRunId
+        });
+    }
     const { activeRunId } = flowState;
     const ledger = await readDelegationLedger(projectRoot);
     const events = await readDelegationEvents(projectRoot);
@@ -553,6 +583,37 @@ export async function checkMandatoryDelegations(projectRoot, stage, options = {}
         legacyInferredCompletions,
         corruptEventLines: events.corruptLines,
         staleWorkers,
-        expectedMode
+        expectedMode,
+        skippedByTrack
     };
 }
+/**
+ * Wave 24 (v6.0.0) — append a non-delegation audit event to
+ * `delegation-events.jsonl` recording that the mandatory delegation
+ * gate was skipped because of the active track / task class. Plays the
+ * same audit role as a `waived` row but does NOT carry an agent —
+ * downstream tooling treats `event === "mandatory_delegations_skipped_by_track"`
+ * lines as informational.
+ *
+ * Failures are swallowed: the audit log is best-effort. Missing the
+ * event must never block stage advance because the gate skip itself is
+ * authoritative.
+ */
+async function recordMandatorySkippedByTrack(projectRoot, params) {
+    const eventsPath = delegationEventsPath(projectRoot);
+    const payload = {
+        event: "mandatory_delegations_skipped_by_track",
+        stage: params.stage,
+        track: params.track,
+        taskClass: params.taskClass,
+        runId: params.runId,
+        ts: new Date().toISOString()
+    };
+    try {
+        await fs.mkdir(path.dirname(eventsPath), { recursive: true });
+        await fs.appendFile(eventsPath, `${JSON.stringify(payload)}\n`, "utf8");
+    }
+    catch {
+        // best-effort audit; never block stage advance.
+    }
+}

package/dist/harness-adapters.js

@@ -349,7 +349,7 @@ Before responding to a coding request:
 
 Three rules apply to every cclaw stage in this project, regardless of which skills loaded:
 
-1. **Q&A convergence before drafting** — for brainstorm / scope / design, walk the stage forcing questions one at a time via the harness-native question tool (Claude \`AskUserQuestion\`, Cursor \`AskQuestion\`, Codex \`request_user_input\`, Gemini \`ask_user\`). The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence has not been reached. Convergence is satisfied 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 (Ralph-Loop), or (c) an explicit user stop-signal row is recorded. The fixed count floor (10 for standard) was removed in Wave 23.
+1. **Q&A convergence before drafting** — for brainstorm / scope / design, walk the stage forcing questions one at a time via the harness-native question tool (Claude \`AskUserQuestion\`, Cursor \`AskQuestion\`, Codex \`request_user_input\`, Gemini \`ask_user\`). The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence has not been reached. Convergence is satisfied when ANY of: (a) every forcing-question topic id is tagged \`[topic:<id>]\` in at least one \`## Q&A Log\` row, (b) the last 2 substantive rows produce no decision-changing impact (Ralph-Loop), or (c) an explicit user stop-signal row is recorded. The fixed count floor (10 for standard) was removed in Wave 23. Wave 24 (v6.0.0) made \`[topic:<id>]\` tagging mandatory (no English keyword fallback) so the gate works in any natural language.
 2. **Subagents run after Q&A approval** — mandatory subagents in brainstorm / scope / design (\`product-discovery\`, \`critic\`, \`planner\`, \`architect\`, \`test-author\`) run only AFTER the user approves the elicitation outcome. See each stage's "Run Phase: post-elicitation" rows in the materialized Automatic Subagent Dispatch table.
 3. **No command-line echo to chat** — the user does not run cclaw helpers manually. Never paste \`node .cclaw/hooks/...\` invocations, \`--evidence-json '{...}'\` payloads, or shell hash commands (\`shasum\`, \`sha256sum\`, \`Get-FileHash\`, \`certutil\`, etc.) into chat. Run helpers via the tool layer; report only the resulting summary.
 

package/dist/internal/advance-stage/advance.d.ts

@@ -19,6 +19,8 @@ interface InternalValidationReport {
         corruptEventLines: number[];
         staleWorkers: string[];
         expectedMode: string;
+        /** Wave 24: true when mandatoryAgentsFor returned [] for the run's track / taskClass. */
+        skippedByTrack: boolean;
     };
     gates: {
         ok: boolean;

package/dist/internal/advance-stage/advance.js

@@ -111,7 +111,8 @@ export async function buildValidationReport(projectRoot, flowState, options = {}
             legacyInferredCompletions: delegation.legacyInferredCompletions,
             corruptEventLines: delegation.corruptEventLines,
             staleWorkers: delegation.staleWorkers,
-            expectedMode: delegation.expectedMode
+            expectedMode: delegation.expectedMode,
+            skippedByTrack: delegation.skippedByTrack
         },
         gates: {
             ok: gates.ok,

package/package.json

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