cclaw-cli 6.0.0 → 6.1.1

package/dist/artifact-linter/shared.js

@@ -1045,16 +1045,46 @@ export const INTERACTION_EDGE_CASE_REQUIREMENTS = [
     },
     { label: "zombie connection", pattern: /\bzombie[\s-]?connection\b/iu }
 ];
-export function validateInteractionEdgeCaseMatrix(sectionBody) {
+const INTERACTION_EDGE_CASE_NA_PATTERN = /^\s*n\s*\/\s*a\b/iu;
+const INTERACTION_EDGE_CASE_NA_WITH_REASON_PATTERN = /^\s*n\s*\/\s*a\s*[—–\-:]\s*\S/iu;
+const INTERACTION_EDGE_CASE_NETWORK_DEPENDENT_LABELS = new Set([
+    "nav-away-mid-request",
+    "10K-result dataset",
+    "background-job abandonment",
+    "zombie connection"
+]);
+function shouldRelaxNetworkDependentEdgeCases(context) {
+    if (!context.liteTier)
+        return false;
+    const sections = context.sections ?? null;
+    if (!sections)
+        return true;
+    const diagramBody = sectionBodyByName(sections, "Architecture Diagram");
+    const failureModeBody = sectionBodyByName(sections, "Failure Mode Table");
+    const failureModeRowCount = failureModeBody !== null ? getMarkdownTableRows(failureModeBody).length : 0;
+    if (failureModeRowCount > 0)
+        return false;
+    if (diagramBody && DIAGRAM_EXTERNAL_DEPENDENCY_PATTERN.test(diagramBody))
+        return false;
+    return true;
+}
+export function validateInteractionEdgeCaseMatrix(sectionBody, context = {}) {
     const rows = getMarkdownTableRows(sectionBody);
+    const relaxNetworkRows = shouldRelaxNetworkDependentEdgeCases(context);
     if (rows.length === 0) {
+        if (relaxNetworkRows) {
+            return {
+                ok: true,
+                details: "Data Flow Interaction Edge Case matrix is advisory for lite-tier no-network designs (no Failure Mode Table rows and no external-dependency nodes detected)."
+            };
+        }
         return {
             ok: false,
             details: "Data Flow must include an Interaction Edge Case matrix table with required rows."
         };
     }
     const seen = new Map();
-    for (const [index, row] of rows.entries()) {
+    for (const [, row] of rows.entries()) {
         const labelCell = (row[0] ?? "").trim();
         if (!labelCell)
             continue;
@@ -1067,15 +1097,31 @@ export function validateInteractionEdgeCaseMatrix(sectionBody) {
                 details: `Interaction Edge Case row "${requirement.label}" must include 4 columns: Edge case | Handled? | Design response | Deferred item.`
             };
         }
-        const handled = parseBinaryFlag((row[1] ?? "").trim());
+        const handledRaw = (row[1] ?? "").trim();
+        const handled = parseBinaryFlag(handledRaw);
         const response = (row[2] ?? "").trim();
         const deferred = (row[3] ?? "").trim();
-        if (handled === "unknown") {
+        const isNA = INTERACTION_EDGE_CASE_NA_PATTERN.test(handledRaw);
+        if (handled === "unknown" && !isNA) {
             return {
                 ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" must mark Handled? as yes/no.`
+                details: `Interaction Edge Case row "${requirement.label}" must mark Handled? as yes/no, or write \`N/A — <reason>\` (em-dash + free-text reason) when the case does not apply.`
             };
         }
+        if (isNA) {
+            // Wave 25: `N/A — <reason>` short-circuits both the "must mark
+            // yes/no" rule and the "must reference a deferred item id"
+            // rule. The reason satisfies justification.
+            const hasReason = INTERACTION_EDGE_CASE_NA_WITH_REASON_PATTERN.test(handledRaw) || response.length > 0;
+            if (!hasReason) {
+                return {
+                    ok: false,
+                    details: `Interaction Edge Case row "${requirement.label}" marked N/A but missing reason. Use \`N/A — <reason>\` (em-dash + free-text reason) in the Handled? cell or fill the Design response cell.`
+                };
+            }
+            seen.set(requirement.label, true);
+            continue;
+        }
         if (!response) {
             return {
                 ok: false,
@@ -1085,7 +1131,7 @@ export function validateInteractionEdgeCaseMatrix(sectionBody) {
         if (handled === "no" && (!deferred || /\bnone\b/iu.test(deferred))) {
             return {
                 ok: false,
-                details: `Interaction Edge Case row "${requirement.label}" is unhandled and must reference a deferred item id (for example D-12).`
+                details: `Interaction Edge Case row "${requirement.label}" is unhandled and must reference a deferred item id (for example D-12) or mark Handled? as \`N/A — <reason>\`.`
             };
         }
         seen.set(requirement.label, true);
@@ -1093,15 +1139,27 @@ export function validateInteractionEdgeCaseMatrix(sectionBody) {
     const missing = INTERACTION_EDGE_CASE_REQUIREMENTS
         .map((requirement) => requirement.label)
         .filter((label) => !seen.has(label));
-    if (missing.length > 0) {
+    const stillMissing = relaxNetworkRows
+        ? missing.filter((label) => !INTERACTION_EDGE_CASE_NETWORK_DEPENDENT_LABELS.has(label))
+        : missing;
+    const advisoryMissing = relaxNetworkRows
+        ? missing.filter((label) => INTERACTION_EDGE_CASE_NETWORK_DEPENDENT_LABELS.has(label))
+        : [];
+    if (stillMissing.length > 0) {
+        const advisoryNote = advisoryMissing.length > 0
+            ? ` (${advisoryMissing.length} network-dependent row(s) demoted to advisory by lite-tier no-network detection: ${advisoryMissing.join(", ")})`
+            : "";
         return {
             ok: false,
-            details: `Interaction Edge Case matrix is missing required row(s): ${missing.join(", ")}.`
+            details: `Interaction Edge Case matrix is missing required row(s): ${stillMissing.join(", ")}${advisoryNote}.`
         };
     }
+    const advisoryNote = advisoryMissing.length > 0
+        ? ` (${advisoryMissing.length} network-dependent row(s) advisory under lite-tier no-network: ${advisoryMissing.join(", ")})`
+        : "";
     return {
         ok: true,
-        details: "Interaction Edge Case matrix contains all required rows with handled/deferred status."
+        details: `Interaction Edge Case matrix contains all required rows with handled/deferred status${advisoryNote}.`
     };
 }
 export const PRE_SCOPE_AUDIT_SIGNALS = [
@@ -1128,9 +1186,23 @@ export function validatePreScopeSystemAudit(sectionBody) {
         details: "Pre-Scope System Audit captures git log/diff/stash/debt-marker checks."
     };
 }
-export const DIAGRAM_ARROW_PATTERN = /(?:<--?>|<?==?>|--?>|->>|=>|-\.->|→|⟶|↦)/u;
+export const DIAGRAM_ARROW_PATTERN = /(?:<--?>|<?==?>|--?>|->>|=>|-\.->|→|⟶|↦|={2,}>|-{3,}>|\.{3,}>|-(?:\s-){1,}\s?->)/u;
 export const DIAGRAM_FAILURE_EDGE_PATTERN = /\b(fail(?:ed|ure)?|error|timeout|fallback|degrad(?:e|ed|ation)|retry|backoff|circuit|unavailable|recover(?:y)?|rescue|mitigat(?:e|ion)|rollback|exception|abort|dead[\s-]?letter|dlq)\b/iu;
 export const DIAGRAM_GENERIC_NODE_PATTERN = /\b(service|component|module|system)\s*(?:[A-Z0-9])?\b/iu;
+/**
+ * Wave 25 (v6.1.0) — external-dependency keywords that trigger the
+ * failure-edge requirement. The architecture diagram is allowed to
+ * omit failure edges only when ALL of:
+ *   - Failure Mode Table has zero rows.
+ *   - The diagram body mentions no external-dependency keyword.
+ *
+ * Static landing pages (3 HTML/CSS/JS files, no network) match this:
+ * no failure modes to map, no external systems to fail. The previous
+ * blanket "must include at least one failure-edge" rule produced
+ * ceremony-only failures that the agent worked around with fake
+ * `(timeout)` annotations, defeating the spirit of the rule.
+ */
+export const DIAGRAM_EXTERNAL_DEPENDENCY_PATTERN = /\b(http|https|api|rest|grpc|graphql|websocket|socket|tcp|udp|rpc|fetch|request|database|db|sql|postgres|mysql|sqlite|mongo|redis|cache|queue|kafka|rabbitmq|sqs|sns|s3|cdn|external|upstream|downstream|third[\s-]?party|webhook|cloud|service[\s-]?bus|event[\s-]?bus|broker|stream|topic)\b/iu;
 export const TEST_COMMAND_MARKER_PATTERN = /\b(?:npm|pnpm|yarn|bun|vitest|jest|pytest|go test|cargo test|mvn test|gradle test|dotnet test)\b/iu;
 export const RED_FAILURE_MARKER_PATTERN = /\b(?:fail|failed|failing|assertionerror|cannot find|exception|error|exit code\s*[:=]?\s*[1-9])\b/iu;
 export const GREEN_SUCCESS_MARKER_PATTERN = /\b(?:pass|passed|green|ok|0 failed|exit code\s*[:=]?\s*0)\b/iu;
@@ -1155,18 +1227,158 @@ export function hasFailureEdgeInDiagram(sectionBody) {
 export function hasLabeledDiagramArrow(lines) {
     return lines.some((line) => /\|[^|]+\|/u.test(line) || /:\s*[A-Za-z]/u.test(line));
 }
+/**
+ * Wave 25 (v6.1.0) — accepted async edge patterns. Returns true when
+ * a line carries any of:
+ *
+ *   - `-.->`, `-->>`, `~~>` (mermaid dotted/messaging arrows)
+ *   - `- - ->` (loose dotted ASCII arrow with optional spaces)
+ *   - `.....>` (3-or-more dots followed by `>`)
+ *   - `\basync\b` text token (label-based)
+ *   - `[async]` bracketed label, `async:` prefix, `async:` cell content
+ *
+ * The error message printed when this fails (see
+ * `validateArchitectureDiagram`) lists every accepted pattern
+ * verbatim so the agent does not have to guess.
+ */
 export function hasAsyncDiagramEdge(lines) {
-    return lines.some((line) => /-\.->|-->>|~~>|\basync\b/iu.test(line));
+    return lines.some((line) => {
+        if (/-\.->|-->>|~~>/u.test(line))
+            return true;
+        if (/-(?:\s-){1,}\s?->/u.test(line))
+            return true;
+        if (/\.{3,}\s*>/u.test(line))
+            return true;
+        if (/\basync\b/iu.test(line))
+            return true;
+        if (/\[\s*async\s*\]/iu.test(line))
+            return true;
+        if (/(?:^|[\s|:])async\s*:/iu.test(line))
+            return true;
+        return false;
+    });
 }
+/**
+ * Wave 25 (v6.1.0) — accepted sync edge patterns. Returns true when a
+ * line carries any of:
+ *
+ *   - `\bsync\b` text token (label-based)
+ *   - `[sync]` bracketed label, `sync:` prefix, `sync:` cell content
+ *   - Solid `-->`, `->`, `=>`, `→`, `⟶`, `↦` arrow that is NOT a known
+ *     dotted/async variant (`-.->`, `-->>`, `~~>`)
+ *   - `===>` (3+ `=` then `>`) and `--->` (3+ `-` then `>`) heavy solid
+ *     arrows
+ */
 export function hasSyncDiagramEdge(lines) {
     return lines.some((line) => {
-        if (/\bsync\b/iu.test(line))
+        if (/\bsync\b/iu.test(line) && !/\basync\b/iu.test(line))
+            return true;
+        if (/\[\s*sync\s*\]/iu.test(line))
+            return true;
+        if (/(?:^|[\s|:])sync\s*:/iu.test(line))
+            return true;
+        if (/={2,}>/u.test(line))
+            return true;
+        if (/-{3,}>/u.test(line))
             return true;
         if (!/(-->|->|=>|→|⟶|↦)/u.test(line))
             return false;
-        return !/-\.->|-->>|~~>/u.test(line);
+        if (/-\.->|-->>|~~>/u.test(line))
+            return false;
+        if (/-(?:\s-){1,}\s?->/u.test(line))
+            return false;
+        return true;
     });
 }
+/**
+ * Wave 25 (v6.1.0) — exact accepted-pattern list shown in the error
+ * message when sync/async distinction fails. Keep in sync with
+ * `hasAsyncDiagramEdge` / `hasSyncDiagramEdge` above.
+ */
+export const DIAGRAM_SYNC_ASYNC_ACCEPTED_PATTERNS = [
+    "Solid arrows: `-->`, `->`, `===>`, `--->`, `=>`, `→`, `⟶`, `↦`",
+    "Dotted/async arrows: `-.->`, `-->>`, `~~>`, `- - ->`, `.....>`",
+    "Text labels on the same line: `sync` / `async`",
+    "Bracket labels: `[sync]` / `[async]`",
+    "Cell-prefix labels: `sync:` / `async:` (e.g. `A -->|sync: persist| B`)"
+];
+/**
+ * Wave 25 (v6.1.0) — Architecture Diagram structural check.
+ *
+ * Promoted out of `validateSectionBody` so it can take a `sections`
+ * map and conditionally enforce the failure-edge rule based on
+ * cross-section context (Failure Mode Table presence + diagram body
+ * mentioning external-dependency keywords).
+ */
+export function validateArchitectureDiagram(sectionBody, context = {}) {
+    const edgeLines = diagramEdgeLines(sectionBody);
+    if (edgeLines.length === 0) {
+        return {
+            ok: false,
+            details: "Architecture Diagram must include at least one directional edge line (for example `A -->|action| B`)."
+        };
+    }
+    if (!hasLabeledDiagramArrow(edgeLines)) {
+        return {
+            ok: false,
+            details: "Architecture Diagram must label each edge with an action/message (for example `A -->|sync: persist| B`)."
+        };
+    }
+    const genericLine = edgeLines.find((line) => DIAGRAM_GENERIC_NODE_PATTERN.test(line));
+    if (genericLine) {
+        return {
+            ok: false,
+            details: `Architecture Diagram uses a generic node label in edge "${genericLine}". Use concrete component names instead of placeholders like Service/Component.`
+        };
+    }
+    if (!hasAsyncDiagramEdge(edgeLines) || !hasSyncDiagramEdge(edgeLines)) {
+        const acceptedList = DIAGRAM_SYNC_ASYNC_ACCEPTED_PATTERNS.map((line) => `  - ${line}`).join("\n");
+        return {
+            ok: false,
+            details: `Architecture Diagram must distinguish sync vs async edges. Accepted patterns:\n${acceptedList}\nExample line that satisfies both: \`Browser -->|sync: render| App\` plus \`App -.->|async: log| Telemetry\`.`
+        };
+    }
+    if (!shouldEnforceFailureEdge(sectionBody, context)) {
+        return {
+            ok: true,
+            details: "Architecture Diagram includes labeled directional edges with sync/async distinction; failure-edge enforcement skipped (no failure-mode rows and no external-dependency nodes detected)."
+        };
+    }
+    if (!hasFailureEdgeInDiagram(sectionBody)) {
+        return {
+            ok: false,
+            details: "Architecture Diagram must include at least one failure-edge arrow with a failure keyword (for example: timeout, error, fallback, degraded, retry). Mark a failure path in the diagram (e.g. `App -->|timeout| FallbackCache`)."
+        };
+    }
+    return {
+        ok: true,
+        details: "Architecture Diagram contains labeled edges, sync/async distinction, and a failure-edge."
+    };
+}
+/**
+ * Wave 25 (v6.1.0) — decide whether the failure-edge enforcement
+ * should fire for the given Architecture Diagram body. Returns
+ * `false` (skip the rule) when BOTH:
+ *   - The artifact's `## Failure Mode Table` (if present) has zero
+ *     data rows OR is absent entirely.
+ *   - The architecture diagram body mentions NO known external-
+ *     dependency keyword (network, db, queue, …).
+ *
+ * Static landing pages (no network, no failure modes) hit this
+ * path. Designs with even one Failure Mode row OR one external
+ * dependency keyword in the diagram fall through to the legacy
+ * blanket failure-edge requirement.
+ */
+function shouldEnforceFailureEdge(diagramBody, context) {
+    const sections = context.sections ?? null;
+    const failureModeBody = sections ? sectionBodyByName(sections, "Failure Mode Table") : null;
+    const failureModeRowCount = failureModeBody !== null ? getMarkdownTableRows(failureModeBody).length : 0;
+    if (failureModeRowCount > 0)
+        return true;
+    if (DIAGRAM_EXTERNAL_DEPENDENCY_PATTERN.test(diagramBody))
+        return true;
+    return false;
+}
 export function validateTddRedEvidence(sectionBody) {
     const meaningful = meaningfulLineCount(sectionBody);
     if (meaningful < 2) {
@@ -1569,7 +1781,7 @@ export function collectPatternHits(text, patterns) {
     }
     return hits;
 }
-export function validateSectionBody(sectionBody, rule, sectionName) {
+export function validateSectionBody(sectionBody, rule, sectionName, context = {}) {
     const bodyLines = sectionBody.split(/\r?\n/).map((line) => line.trim());
     const meaningful = meaningfulLineCount(sectionBody);
     if (meaningful === 0) {
@@ -1676,41 +1888,13 @@ export function validateSectionBody(sectionBody, rule, sectionName) {
         return validateRequirementsTaxonomy(sectionBody);
     }
     if (sectionNameNormalized === "data flow") {
-        return validateInteractionEdgeCaseMatrix(sectionBody);
+        return validateInteractionEdgeCaseMatrix(sectionBody, {
+            sections: context.sections ?? null,
+            liteTier: context.liteTier ?? false
+        });
     }
     if (sectionNameNormalized === "architecture diagram") {
-        const edgeLines = diagramEdgeLines(sectionBody);
-        if (edgeLines.length === 0) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must include at least one directional edge line (for example `A -->|action| B`)."
-            };
-        }
-        if (!hasLabeledDiagramArrow(edgeLines)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must label each edge with an action/message (for example `A -->|sync: persist| B`)."
-            };
-        }
-        const genericLine = edgeLines.find((line) => DIAGRAM_GENERIC_NODE_PATTERN.test(line));
-        if (genericLine) {
-            return {
-                ok: false,
-                details: `Architecture Diagram uses a generic node label in edge "${genericLine}". Use concrete component names instead of placeholders like Service/Component.`
-            };
-        }
-        if (!hasAsyncDiagramEdge(edgeLines) || !hasSyncDiagramEdge(edgeLines)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must distinguish sync vs async edges (for example solid + dotted arrows, or `sync:` and `async:` labels)."
-            };
-        }
-        if (!hasFailureEdgeInDiagram(sectionBody)) {
-            return {
-                ok: false,
-                details: "Architecture Diagram must include at least one failure-edge arrow with a failure keyword (for example: timeout, error, fallback, degraded, retry)."
-            };
-        }
+        return validateArchitectureDiagram(sectionBody, { sections: context.sections ?? null });
     }
     if (sectionNameNormalized === "acceptance criteria" &&
         /observable[\s,]*measurable[\s,]+(and )?falsifiable/iu.test(rule)) {

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/stage-schema.d.ts

@@ -84,6 +84,29 @@ export declare function mandatoryDelegationsForStage(stage: FlowStage, complexit
  */
 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

@@ -818,6 +818,35 @@ export function mandatoryAgentsFor(stage, track, taskClass, complexityTier = "st
         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/delegation.d.ts

@@ -1,6 +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"];
@@ -148,7 +149,10 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
      * 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.
+     * this undefined; the function then falls back to
+     * `flowState.taskClass` (persisted in `flow-state.json`) so the
+     * Wave 24 bugfix-skip remains active across the `cclaw advance-stage`
+     * code path even when no caller forwards an explicit override.
      */
     taskClass?: MandatoryDelegationTaskClass | null;
 }): Promise<{
@@ -177,3 +181,38 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
      */
     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>;