cclaw-cli 5.0.0 → 6.1.0

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.
@@ -1019,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;
@@ -1041,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,
@@ -1059,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);
@@ -1067,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 = [
@@ -1102,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;
@@ -1129,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) {
@@ -1543,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) {
@@ -1650,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)) {