cclaw-cli 5.0.0 → 6.1.0

package/dist/artifact-linter.js

@@ -4,6 +4,8 @@ import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readFlowState } from "./run-persistence.js";
 import { duplicateH2Headings, extractH2Sections, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody } from "./artifact-linter/shared.js";
+import { shouldDemoteArtifactValidationByTrack } from "./content/stage-schema.js";
+import { recordArtifactValidationDemotedByTrack } from "./delegation.js";
 import { lintBrainstormStage } from "./artifact-linter/brainstorm.js";
 import { lintDesignStage } from "./artifact-linter/design.js";
 import { lintPlanStage } from "./artifact-linter/plan.js";
@@ -105,6 +107,34 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
     const overrideSet = isTrivialOverride
         ? new Set(schema.trivialOverrideSections.map((s) => normalizeHeadingTitle(s).toLowerCase()))
         : null;
+    // Wave 25: precompute the lite-tier signal so the per-section
+    // validators (Interaction Edge Case matrix today, others tomorrow)
+    // can relax network-dependent mandatory rows for lite/quick/bugfix
+    // runs without each validator having to re-derive the predicate.
+    // Same flow-state read powers the post-loop demotion + audit log
+    // below; we cache the result here to avoid two disk reads.
+    let activeStageFlags = [];
+    let taskClass = null;
+    let activeRunId = null;
+    try {
+        const flowState = await readFlowState(projectRoot);
+        const hint = flowState.interactionHints?.[stage];
+        if (hint?.skipQuestions === true)
+            activeStageFlags.push("--skip-questions");
+        taskClass = flowState.taskClass ?? null;
+        activeRunId = flowState.activeRunId ?? null;
+    }
+    catch {
+        activeStageFlags = [];
+        taskClass = null;
+        activeRunId = null;
+    }
+    for (const extra of options.extraStageFlags ?? []) {
+        if (typeof extra === "string" && extra.length > 0 && !activeStageFlags.includes(extra)) {
+            activeStageFlags.push(extra);
+        }
+    }
+    const liteTierForValidators = shouldDemoteArtifactValidationByTrack(track, taskClass);
     for (const v of schema.artifactValidation) {
         const sectionKey = normalizeHeadingTitle(v.section).toLowerCase();
         const scopeBoundaryAlias = stage === "scope" && sectionKey === "in scope / out of scope";
@@ -122,7 +152,10 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
                 : effectiveRequiredFromOverride;
         const validation = body === null
             ? { ok: false, details: `No ## heading matching required section "${v.section}".` }
-            : validateSectionBody(body, v.validationRule, v.section);
+            : validateSectionBody(body, v.validationRule, v.section, {
+                sections,
+                liteTier: liteTierForValidators
+            });
         const found = hasHeading && validation.ok;
         findings.push({
             section: v.section,
@@ -158,21 +191,6 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
             details: `${learnings.details}${meaningfulStageNoneWarning}`
         });
     }
-    let activeStageFlags = [];
-    try {
-        const flowState = await readFlowState(projectRoot);
-        const hint = flowState.interactionHints?.[stage];
-        if (hint?.skipQuestions === true)
-            activeStageFlags.push("--skip-questions");
-    }
-    catch {
-        activeStageFlags = [];
-    }
-    for (const extra of options.extraStageFlags ?? []) {
-        if (typeof extra === "string" && extra.length > 0 && !activeStageFlags.includes(extra)) {
-            activeStageFlags.push(extra);
-        }
-    }
     const stageContext = {
         projectRoot,
         stage,
@@ -188,7 +206,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         staleDiagramAuditEnabled,
         isTrivialOverride,
         overrideSet,
-        activeStageFlags
+        activeStageFlags,
+        taskClass
     };
     switch (stage) {
         case "brainstorm":
@@ -257,6 +276,53 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
             });
         }
     }
+    const demote = shouldDemoteArtifactValidationByTrack(track, taskClass);
+    const demotedSections = [];
+    if (demote) {
+        for (const finding of findings) {
+            if (!ARTIFACT_VALIDATION_LITE_DEMOTE_SECTIONS.has(finding.section))
+                continue;
+            if (finding.found)
+                continue;
+            if (!finding.required)
+                continue;
+            finding.required = false;
+            finding.details =
+                `${finding.details} (Wave 25: demoted to advisory by track="${track}"` +
+                    (taskClass ? `, taskClass="${taskClass}"` : "") +
+                    ").";
+            demotedSections.push(finding.section);
+        }
+        if (demotedSections.length > 0 && activeRunId) {
+            await recordArtifactValidationDemotedByTrack(projectRoot, {
+                stage,
+                track,
+                taskClass: taskClass ?? null,
+                runId: activeRunId,
+                sections: demotedSections
+            }).catch(() => { });
+        }
+    }
     const passed = findings.every((f) => !f.required || f.found);
     return { stage, file: relFile, passed, findings };
 }
+/**
+ * Wave 25 (v6.1.0) — section names whose required-finding outcome is
+ * demoted from blocking → advisory when
+ * `shouldDemoteArtifactValidationByTrack(track, taskClass)` returns
+ * `true`. Mirrors the user-reported quick-tier failure modes:
+ *
+ *  - `Architecture Diagram` — sync/async + failure-edge enforcement
+ *  - `Data Flow` — Interaction Edge Case mandatory rows
+ *  - `Stale Diagram Drift Check` — blast-radius file mtime audit
+ *  - `Expansion Strategist Delegation` — product-discovery delegation
+ *
+ * Findings remain in the result so the caller can surface them as
+ * advisory hints; only `required` flips to `false`.
+ */
+const ARTIFACT_VALIDATION_LITE_DEMOTE_SECTIONS = new Set([
+    "Architecture Diagram",
+    "Data Flow",
+    "Stale Diagram Drift Check",
+    "Expansion Strategist Delegation"
+]);

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,58 @@ 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[];
+/**
+ * Wave 25 (v6.1.0) — track-aware artifact validation demotion.
+ *
+ * Mirrors `mandatoryAgentsFor`'s skip logic for the small-fix lanes.
+ * Returns `true` when artifact-level "advanced" validation rules
+ * (architecture-diagram async/failure edges, interaction edge-case
+ * mandatory rows, stale-diagram drift check, expansion-strategist
+ * delegation) should be DEMOTED from required → advisory.
+ *
+ *   - `track === "quick"` — quick-tier runs (single-purpose
+ *     landing-page edits, doc tweaks, config nudges). The advanced
+ *     checks fire on architecture surfaces a quick-track artifact
+ *     usually doesn't have. Same trigger as Wave 24 Phase B.
+ *   - `taskClass === "software-bugfix"` — bugfixes carry RED-first
+ *     repro coverage; tdd/review own the safety surface.
+ *
+ * When this returns `true`, the linter still runs the rules and prints
+ * their findings (so authors see them as advisory info), but does NOT
+ * block stage advance. An audit event of type
+ * `artifact_validation_demoted_by_track` is appended to
+ * `delegation-events.jsonl` once per stage advance for traceability.
+ */
+export declare function shouldDemoteArtifactValidationByTrack(track: FlowTrack, taskClass?: MandatoryDelegationTaskClass | null): boolean;
 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,42 @@ 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);
+}
+/**
+ * Wave 25 (v6.1.0) — track-aware artifact validation demotion.
+ *
+ * Mirrors `mandatoryAgentsFor`'s skip logic for the small-fix lanes.
+ * Returns `true` when artifact-level "advanced" validation rules
+ * (architecture-diagram async/failure edges, interaction edge-case
+ * mandatory rows, stale-diagram drift check, expansion-strategist
+ * delegation) should be DEMOTED from required → advisory.
+ *
+ *   - `track === "quick"` — quick-tier runs (single-purpose
+ *     landing-page edits, doc tweaks, config nudges). The advanced
+ *     checks fire on architecture surfaces a quick-track artifact
+ *     usually doesn't have. Same trigger as Wave 24 Phase B.
+ *   - `taskClass === "software-bugfix"` — bugfixes carry RED-first
+ *     repro coverage; tdd/review own the safety surface.
+ *
+ * When this returns `true`, the linter still runs the rules and prints
+ * their findings (so authors see them as advisory info), but does NOT
+ * block stage advance. An audit event of type
+ * `artifact_validation_demoted_by_track` is appended to
+ * `delegation-events.jsonl` once per stage advance for traceability.
+ */
+export function shouldDemoteArtifactValidationByTrack(track, taskClass) {
+    if (track === "quick")
+        return true;
+    if (taskClass === "software-bugfix")
+        return true;
+    return false;
+}
 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,5 +1,7 @@
 import { type SubagentFallback } from "./harness-adapters.js";
+import { type MandatoryDelegationTaskClass } from "./content/stage-schema.js";
 import type { FlowStage } from "./types.js";
+import type { FlowState } from "./flow-state.js";
 export type DelegationMode = "mandatory" | "proactive";
 export type DelegationStatus = "scheduled" | "launched" | "acknowledged" | "completed" | "failed" | "waived" | "stale";
 export declare const DELEGATION_DISPATCH_SURFACES: readonly ["claude-task", "cursor-task", "opencode-agent", "codex-agent", "generic-task", "role-switch", "manual"];
@@ -143,6 +145,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 +169,47 @@ 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;
 }>;
+/**
+ * Wave 25 (v6.1.0) — append a non-delegation audit event recording
+ * that one or more required artifact-validation findings were
+ * demoted from blocking to advisory because the active run is on a
+ * small-fix lane (`track === "quick"` or `taskClass === "software-bugfix"`).
+ *
+ * The event mirrors the Wave 24 `mandatory_delegations_skipped_by_track`
+ * audit pattern: best-effort write to `delegation-events.jsonl`, no
+ * agent payload, recognized by `readDelegationEvents` so it does not
+ * corrupt downstream parsers. Failures are swallowed.
+ */
+export declare function recordArtifactValidationDemotedByTrack(projectRoot: string, params: {
+    stage: FlowStage;
+    track: FlowState["track"];
+    taskClass: MandatoryDelegationTaskClass | null;
+    runId: string;
+    sections: string[];
+}): Promise<void>;
+/**
+ * Wave 25 (v6.1.0) — append a non-delegation audit event recording
+ * that the scope-stage Expansion Strategist (`product-discovery`)
+ * delegation requirement was skipped because the active run is on a
+ * small-fix lane (`track === "quick"` or `taskClass === "software-bugfix"`).
+ *
+ * Mirrors the Wave 24 `mandatory_delegations_skipped_by_track`
+ * audit pattern: best-effort write to `delegation-events.jsonl`, no
+ * agent payload, recognized by `readDelegationEvents` so it does not
+ * corrupt downstream parsers. Failures are swallowed.
+ */
+export declare function recordExpansionStrategistSkippedByTrack(projectRoot: string, params: {
+    track: FlowState["track"];
+    taskClass: MandatoryDelegationTaskClass | null;
+    runId: string;
+    selectedScopeMode: string;
+}): Promise<void>;