cclaw-cli 3.0.0 → 5.0.0

package/dist/artifact-linter/brainstorm.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { checkCriticPredictionsContract, sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, getMarkdownTableRows, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
+import { checkCriticPredictionsContract, evaluateQaLogFloor, sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, getMarkdownTableRows, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
+import { readFlowState } from "../run-persistence.js";
 export async function lintBrainstormStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     const qaLogBody = sectionBodyByName(sections, "Q&A Log");
@@ -9,7 +10,7 @@ export async function lintBrainstormStage(ctx) {
     findings.push({
         section: "qa_log_missing",
         required: false,
-        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        rule: "[P2] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
         found: qaLogOk,
         details: qaLogOk
             ? `Q&A Log contains ${qaLogRows.length} data row(s).`
@@ -17,6 +18,17 @@ export async function lintBrainstormStage(ctx) {
                 ? "Missing `## Q&A Log` section."
                 : "Q&A Log is present but has zero data rows."
     });
+    if (!brainstormShortCircuitActivated) {
+        const skipQuestions = ctx.activeStageFlags.includes("--skip-questions");
+        const floor = evaluateQaLogFloor(qaLogBody, track, "brainstorm", { skipQuestions });
+        findings.push({
+            section: "qa_log_unconverged",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            found: floor.ok,
+            details: floor.details
+        });
+    }
     // Brainstorm Iron Law: "NO ARTIFACT IS COMPLETE WITHOUT AN EXPLICITLY
     // APPROVED DIRECTION — SILENCE IS NOT APPROVAL." Previously this was
     // prose-only — nothing failed when the Selected Direction section
@@ -268,6 +280,43 @@ export async function lintBrainstormStage(ctx) {
                 : `Outside Voice section is missing field(s): ${missing.join(", ")}.`
         });
     }
+    let ideaHint = {};
+    try {
+        const flowState = await readFlowState(projectRoot);
+        const hint = flowState.interactionHints?.brainstorm;
+        if (hint) {
+            ideaHint = {
+                fromIdeaArtifact: hint.fromIdeaArtifact,
+                fromIdeaCandidateId: hint.fromIdeaCandidateId
+            };
+        }
+    }
+    catch {
+        ideaHint = {};
+    }
+    if (ideaHint.fromIdeaArtifact) {
+        const carryBody = sectionBodyByName(sections, "Idea Evidence Carry-forward");
+        const hasSection = carryBody !== null && meaningfulLineCount(carryBody) > 0;
+        const sourceCited = hasSection &&
+            carryBody.includes(ideaHint.fromIdeaArtifact);
+        const candidateCited = ideaHint.fromIdeaCandidateId
+            ? hasSection && carryBody.toUpperCase().includes(ideaHint.fromIdeaCandidateId.toUpperCase())
+            : true;
+        const ok = hasSection && sourceCited && candidateCited;
+        findings.push({
+            section: "brainstorm.idea_evidence_carry_forward",
+            required: true,
+            rule: "[P1] brainstorm.idea_evidence_carry_forward — when `flow-state.interactionHints.brainstorm.fromIdeaArtifact` is set (Wave 23 / v5.0.0), the brainstorm artifact MUST include `## Idea Evidence Carry-forward` citing the idea artifact path and chosen `I-#`. Reuse divergent + critique + rank work from `/cc-ideate` as the `baseline` Approach; only newly generate the higher-upside challenger row(s).",
+            found: ok,
+            details: ok
+                ? `Idea Evidence Carry-forward cites ${ideaHint.fromIdeaArtifact}${ideaHint.fromIdeaCandidateId ? ` (${ideaHint.fromIdeaCandidateId})` : ""}.`
+                : !hasSection
+                    ? `Brainstorm started from /cc-ideate (artifact ${ideaHint.fromIdeaArtifact}${ideaHint.fromIdeaCandidateId ? `, candidate ${ideaHint.fromIdeaCandidateId}` : ""}) but \`## Idea Evidence Carry-forward\` is missing or empty.`
+                    : !sourceCited
+                        ? `\`## Idea Evidence Carry-forward\` does not cite the source idea artifact path \`${ideaHint.fromIdeaArtifact}\`.`
+                        : `\`## Idea Evidence Carry-forward\` does not cite the chosen candidate id \`${ideaHint.fromIdeaCandidateId ?? ""}\`.`
+        });
+    }
     const wavePlansDir = path.join(projectRoot, ".cclaw", "wave-plans");
     let wavePlanEntries = [];
     try {

package/dist/artifact-linter/design.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
 import { exists } from "../fs-utils.js";
 import { CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
-import { checkCriticPredictionsContract, evaluateLayeredDocumentReviewStatus, extractMarkdownSectionBody, getMarkdownTableRows, meaningfulLineCount, sectionBodyByName, markdownFieldRegex } from "./shared.js";
+import { checkCriticPredictionsContract, evaluateLayeredDocumentReviewStatus, evaluateQaLogFloor, extractMarkdownSectionBody, getMarkdownTableRows, meaningfulLineCount, sectionBodyByName, markdownFieldRegex } from "./shared.js";
 const DESIGN_DIAGRAM_REQUIREMENTS = {
     lightweight: [
         {
@@ -203,14 +203,14 @@ async function runStaleDiagramAudit(projectRoot, artifactPath, artifactRaw, code
     };
 }
 export async function lintDesignStage(ctx) {
-    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride, activeStageFlags } = ctx;
     const qaLogBody = sectionBodyByName(sections, "Q&A Log");
     const qaLogRows = qaLogBody ? getMarkdownTableRows(qaLogBody) : [];
     const qaLogOk = qaLogBody !== null && qaLogRows.length > 0;
     findings.push({
         section: "qa_log_missing",
         required: false,
-        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        rule: "[P2] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
         found: qaLogOk,
         details: qaLogOk
             ? `Q&A Log contains ${qaLogRows.length} data row(s).`
@@ -218,6 +218,17 @@ export async function lintDesignStage(ctx) {
                 ? "Missing `## Q&A Log` section."
                 : "Q&A Log is present but has zero data rows."
     });
+    {
+        const skipQuestions = activeStageFlags.includes("--skip-questions");
+        const floor = evaluateQaLogFloor(qaLogBody, track, "design", { skipQuestions });
+        findings.push({
+            section: "qa_log_unconverged",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            found: floor.ok,
+            details: floor.details
+        });
+    }
     const criticPredictions = checkCriticPredictionsContract(sections);
     if (criticPredictions !== null) {
         findings.push({

package/dist/artifact-linter/review-army.d.ts

@@ -21,4 +21,29 @@ export interface ReviewSecurityNoChangeAttestationResult {
  * APPROVED while open Critical findings or shipBlockers remain.
  */
 export declare function checkReviewVerdictConsistency(projectRoot: string): Promise<ReviewVerdictConsistencyResult>;
+export interface ReviewTddDuplicationConflict {
+    findingId: string;
+    tddSeverity: string | null;
+    reviewSeverity: string | null;
+    tddDisposition: string | null;
+    reviewDisposition: string | null;
+}
+export interface ReviewTddDuplicationResult {
+    ok: boolean;
+    errors: string[];
+    conflicts: ReviewTddDuplicationConflict[];
+    tddArtifactExists: boolean;
+    reviewArtifactExists: boolean;
+}
+/**
+ * Cross-artifact duplication guard (Wave 23 / v5.0.0).
+ *
+ * When the same finding ID (`F-NN`) appears in both
+ * `06-tdd.md > Per-Slice Review` and `07-review-army.json`, the
+ * severity and disposition MUST match. Per-slice tdd reviews own
+ * single-slice findings; review cites them, never re-classifies.
+ *
+ * If neither artifact uses `F-NN` IDs, the check is a no-op.
+ */
+export declare function checkReviewTddNoCrossArtifactDuplication(projectRoot: string): Promise<ReviewTddDuplicationResult>;
 export declare function checkReviewSecurityNoChangeAttestation(projectRoot: string): Promise<ReviewSecurityNoChangeAttestationResult>;

package/dist/artifact-linter/review-army.js

@@ -319,6 +319,161 @@ export async function checkReviewVerdictConsistency(projectRoot) {
         shipBlockerCount
     };
 }
+const FINDING_ID_PATTERN = /\bF-\d+\b/giu;
+const SEVERITY_TOKENS = ["Critical", "Important", "Suggestion"];
+const DISPOSITION_TOKENS = ["open", "accepted", "resolved", "deferred", "won't-fix", "wont-fix"];
+function findFirstToken(text, tokens) {
+    for (const token of tokens) {
+        const escaped = token.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+        const regex = new RegExp(`\\b${escaped}\\b`, "iu");
+        if (regex.test(text))
+            return token;
+    }
+    return null;
+}
+function normalizeDisposition(value) {
+    if (value === null)
+        return null;
+    const lower = value.toLowerCase();
+    if (lower === "wont-fix" || lower === "won't-fix")
+        return "won't-fix";
+    return lower;
+}
+function extractTddPerSliceFindings(perSliceBody) {
+    const rows = new Map();
+    const lines = perSliceBody.split(/\r?\n/u);
+    for (const line of lines) {
+        const ids = line.match(FINDING_ID_PATTERN);
+        if (!ids || ids.length === 0)
+            continue;
+        const severity = findFirstToken(line, SEVERITY_TOKENS);
+        const disposition = normalizeDisposition(findFirstToken(line, DISPOSITION_TOKENS));
+        for (const rawId of ids) {
+            const id = rawId.toUpperCase();
+            if (rows.has(id))
+                continue;
+            rows.set(id, { id, severity, disposition });
+        }
+    }
+    return rows;
+}
+/**
+ * Cross-artifact duplication guard (Wave 23 / v5.0.0).
+ *
+ * When the same finding ID (`F-NN`) appears in both
+ * `06-tdd.md > Per-Slice Review` and `07-review-army.json`, the
+ * severity and disposition MUST match. Per-slice tdd reviews own
+ * single-slice findings; review cites them, never re-classifies.
+ *
+ * If neither artifact uses `F-NN` IDs, the check is a no-op.
+ */
+export async function checkReviewTddNoCrossArtifactDuplication(projectRoot) {
+    const tddPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "06-tdd.md");
+    const armyPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "07-review-army.json");
+    const tddArtifactExists = await exists(tddPath);
+    const reviewArtifactExists = await exists(armyPath);
+    if (!tddArtifactExists || !reviewArtifactExists) {
+        return {
+            ok: true,
+            errors: [],
+            conflicts: [],
+            tddArtifactExists,
+            reviewArtifactExists
+        };
+    }
+    const tddRaw = await fs.readFile(tddPath, "utf8");
+    const tddSections = extractH2Sections(tddRaw);
+    const perSliceBody = sectionBodyByName(tddSections, "Per-Slice Review");
+    if (!perSliceBody) {
+        return {
+            ok: true,
+            errors: [],
+            conflicts: [],
+            tddArtifactExists,
+            reviewArtifactExists
+        };
+    }
+    const tddFindings = extractTddPerSliceFindings(perSliceBody);
+    if (tddFindings.size === 0) {
+        return {
+            ok: true,
+            errors: [],
+            conflicts: [],
+            tddArtifactExists,
+            reviewArtifactExists
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await fs.readFile(armyPath, "utf8"));
+    }
+    catch {
+        return {
+            ok: true,
+            errors: [],
+            conflicts: [],
+            tddArtifactExists,
+            reviewArtifactExists
+        };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            ok: true,
+            errors: [],
+            conflicts: [],
+            tddArtifactExists,
+            reviewArtifactExists
+        };
+    }
+    const root = parsed;
+    const findings = Array.isArray(root.findings) ? root.findings : [];
+    const conflicts = [];
+    for (const f of findings) {
+        if (!f || typeof f !== "object" || Array.isArray(f))
+            continue;
+        const o = f;
+        if (typeof o.id !== "string")
+            continue;
+        const id = o.id.toUpperCase();
+        const tddRow = tddFindings.get(id);
+        if (!tddRow)
+            continue;
+        const reviewSeverity = typeof o.severity === "string" ? o.severity : null;
+        const reviewDisposition = normalizeDisposition(typeof o.status === "string" ? o.status : null);
+        const severityMismatch = tddRow.severity !== null &&
+            reviewSeverity !== null &&
+            tddRow.severity.toLowerCase() !== reviewSeverity.toLowerCase();
+        const dispositionMismatch = tddRow.disposition !== null &&
+            reviewDisposition !== null &&
+            tddRow.disposition !== reviewDisposition;
+        if (severityMismatch || dispositionMismatch) {
+            conflicts.push({
+                findingId: id,
+                tddSeverity: tddRow.severity,
+                reviewSeverity,
+                tddDisposition: tddRow.disposition,
+                reviewDisposition
+            });
+        }
+    }
+    const errors = conflicts.map((c) => {
+        const parts = [];
+        if (c.tddSeverity !== null && c.reviewSeverity !== null && c.tddSeverity.toLowerCase() !== c.reviewSeverity.toLowerCase()) {
+            parts.push(`severity tdd=${c.tddSeverity} vs review-army=${c.reviewSeverity}`);
+        }
+        if (c.tddDisposition !== null && c.reviewDisposition !== null && c.tddDisposition !== c.reviewDisposition) {
+            parts.push(`disposition tdd=${c.tddDisposition} vs review-army=${c.reviewDisposition}`);
+        }
+        return `Finding ${c.findingId} appears in both 06-tdd.md > Per-Slice Review and 07-review-army.json with mismatched ${parts.join(" and ")}. Review must cite, not re-classify.`;
+    });
+    return {
+        ok: errors.length === 0,
+        errors,
+        conflicts,
+        tddArtifactExists,
+        reviewArtifactExists
+    };
+}
 export async function checkReviewSecurityNoChangeAttestation(projectRoot) {
     const reviewMdPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "07-review.md");
     if (!(await exists(reviewMdPath))) {

package/dist/artifact-linter/review.js

@@ -1,4 +1,5 @@
 import { markdownFieldRegex, sectionBodyByName } from "./shared.js";
+import { checkReviewTddNoCrossArtifactDuplication } from "./review-army.js";
 export async function lintReviewStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     // Universal Layer 2.7 structural checks (superpowers requesting + receiving).
@@ -62,6 +63,18 @@ export async function lintReviewStage(ctx) {
                 : "Receiving Posture is missing the anti-sycophancy acknowledgement line."
         });
     }
+    const dupResult = await checkReviewTddNoCrossArtifactDuplication(projectRoot);
+    findings.push({
+        section: "review.no_cross_artifact_duplication",
+        required: true,
+        rule: "[P1] review.no_cross_artifact_duplication — when a finding ID appears in both `06-tdd.md > Per-Slice Review` and `07-review-army.json`, severity and disposition must match (review cites tdd; never re-classifies).",
+        found: dupResult.ok,
+        details: dupResult.ok
+            ? dupResult.tddArtifactExists && dupResult.reviewArtifactExists
+                ? "No cross-artifact severity/disposition conflicts between tdd Per-Slice Review and review-army findings."
+                : "Skipped: tdd Per-Slice Review or review-army artifact not present."
+            : dupResult.errors.join(" ")
+    });
     const lensCoverageBody = sectionBodyByName(sections, "Lens Coverage");
     if (lensCoverageBody === null) {
         findings.push({

package/dist/artifact-linter/scope.js

@@ -1,24 +1,17 @@
-import { checkCriticPredictionsContract, sectionBodyByHeadingPrefix, sectionBodyByName, extractCanonicalScopeMode, sectionBodyByAnyName, collectPatternHits, SCOPE_REDUCTION_PATTERNS, validateLockedDecisionAnchors, getMarkdownTableRows } from "./shared.js";
+import { checkCriticPredictionsContract, evaluateQaLogFloor, sectionBodyByHeadingPrefix, sectionBodyByName, extractCanonicalScopeMode, getMarkdownTableRows } from "./shared.js";
 import { readDelegationLedger } from "../delegation.js";
 export async function lintScopeStage(ctx) {
-    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride, activeStageFlags } = ctx;
     const lockedDecisionsBody = sectionBodyByHeadingPrefix(sections, "Locked Decisions") ?? "";
     const scopeSummaryBody = sectionBodyByName(sections, "Scope Summary") ?? "";
     const selectedScopeMode = extractCanonicalScopeMode(scopeSummaryBody);
-    const strictScopeGuards = parsedFrontmatter.hasFrontmatter ||
-        sectionBodyByHeadingPrefix(sections, "Locked Decisions") !== null;
-    const scopeSections = [
-        sectionBodyByAnyName(sections, ["In Scope / Out of Scope", "In Scope", "Out of Scope"]) ?? "",
-        sectionBodyByName(sections, "Scope Summary") ?? "",
-        lockedDecisionsBody
-    ].join("\n");
     const qaLogBody = sectionBodyByName(sections, "Q&A Log");
     const qaLogRows = qaLogBody ? getMarkdownTableRows(qaLogBody) : [];
     const qaLogOk = qaLogBody !== null && qaLogRows.length > 0;
     findings.push({
         section: "qa_log_missing",
         required: false,
-        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        rule: "[P2] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
         found: qaLogOk,
         details: qaLogOk
             ? `Q&A Log contains ${qaLogRows.length} data row(s).`
@@ -26,6 +19,17 @@ export async function lintScopeStage(ctx) {
                 ? "Missing `## Q&A Log` section."
                 : "Q&A Log is present but has zero data rows."
     });
+    {
+        const skipQuestions = activeStageFlags.includes("--skip-questions");
+        const floor = evaluateQaLogFloor(qaLogBody, track, "scope", { skipQuestions });
+        findings.push({
+            section: "qa_log_unconverged",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until forcing-question topics are addressed, the last 2 rows produce no decision-changing impact (Ralph-Loop), or an explicit user stop-signal row is appended.",
+            found: floor.ok,
+            details: floor.details
+        });
+    }
     const strategistRequired = selectedScopeMode === "SCOPE EXPANSION" || selectedScopeMode === "SELECTIVE EXPANSION";
     if (strategistRequired) {
         const delegationLedger = await readDelegationLedger(projectRoot);
@@ -57,28 +61,11 @@ export async function lintScopeStage(ctx) {
             details: criticPredictions.details
         });
     }
-    const reductionHits = collectPatternHits(scopeSections, SCOPE_REDUCTION_PATTERNS);
-    findings.push({
-        section: "No Scope Reduction Language",
-        required: strictScopeGuards,
-        rule: "Scope boundary sections must not use reduction placeholders (`v1`, `for now`, `later`, `temporary`, `placeholder`).",
-        found: reductionHits.length === 0,
-        details: reductionHits.length === 0
-            ? "No scope-reduction phrases detected in scope boundary sections."
-            : `Detected scope-reduction phrase(s): ${reductionHits.join(", ")}.`
-    });
     if (sectionBodyByHeadingPrefix(sections, "Locked Decisions") !== null) {
-        const anchorValidation = validateLockedDecisionAnchors(lockedDecisionsBody);
-        findings.push({
-            section: "Locked Decisions Hash Integrity",
-            required: true,
-            rule: "Locked Decisions section must list unique LD#<sha8> content-derived anchors.",
-            found: anchorValidation.ok,
-            details: anchorValidation.details
-        });
-        // Legacy D-XX rows remain advisory for older artifacts, but new templates
-        // use LD#hash anchors. This check keeps D-XX duplicates visible without
-        // making old artifacts the primary contract.
+        // D-XX IDs are the stable contract. The legacy LD#<sha8> hash anchor
+        // check was removed in Wave 22 (v4.0.0) — it caused agents to spam
+        // shell hash commands when shifting decision rows around, and provided
+        // no signal beyond the D-XX uniqueness check below.
         const listDecisionLines = lockedDecisionsBody
             .split(/\r?\n/u)
             .map((line) => line.trim())
@@ -113,27 +100,19 @@ export async function lintScopeStage(ctx) {
         }
         findings.push({
             section: "Locked Decisions ID Integrity",
-            required: false,
-            rule: "Locked Decisions section must list each decision with a unique stable D-XX ID.",
+            required: true,
+            rule: "Locked Decisions section must list each decision with a unique stable D-XX ID. (D-XX IDs replaced the legacy LD#<sha8> hash anchors in Wave 22.)",
             found: issues.length === 0,
             details: issues.length === 0
                 ? `${rowDecisionIds.length} decision ID(s) recorded with no duplicates.`
                 : issues.join("; ")
         });
     }
-    // Universal Layer 2.2 structural checks (gstack plan-ceo-review). All
-    // present-only — they validate shape when the section exists.
-    const altsBody = sectionBodyByName(sections, "Implementation Alternatives");
-    if (altsBody !== null) {
-        const recommendation = /^RECOMMENDATION:\s*(.+)$/imu.test(altsBody);
-        findings.push({
-            section: "Implementation Alternatives Recommendation",
-            required: true,
-            rule: "Implementation Alternatives must conclude with a `RECOMMENDATION:` line citing the chosen option and rationale.",
-            found: recommendation,
-            details: recommendation
-                ? "Recommendation marker present."
-                : "Missing or empty `RECOMMENDATION:` line under Implementation Alternatives."
-        });
-    }
+    // Wave 23 (v5.0.0): scope no longer owns architecture-tier alternatives
+    // (`## Implementation Alternatives` was removed from the scope template
+    // and stage schema). Design OWNS the architecture-tier decision via
+    // `## Architecture Decision Record (ADR)` and `## Engineering Lock`.
+    // The legacy linter rule `Implementation Alternatives Recommendation`
+    // was removed in Wave 23 — if a legacy artifact still has the section,
+    // it is now treated as informational only.
 }

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

@@ -1,4 +1,95 @@
 import { type FlowStage, type FlowTrack } from "../types.js";
+/**
+ * Stages that run adaptive elicitation. The `qa_log_unconverged` rule
+ * only fires for these. Other stages may still record a Q&A Log but no
+ * convergence floor is enforced.
+ */
+export declare const ELICITATION_STAGES: ReadonlySet<FlowStage>;
+export interface QaLogFloorOptions {
+    /**
+     * When true, downgrades the finding to advisory (`required: false`).
+     * Set when `--skip-questions` was persisted to the active stage flags.
+     */
+    skipQuestions?: boolean;
+    /**
+     * Optional pre-extracted forcing-question topics. When omitted, the
+     * evaluator calls `extractForcingQuestions(stage)` which scans the
+     * stage's checklist row.
+     */
+    forcingQuestions?: string[];
+}
+export interface QaLogFloorResult {
+    /** Whether convergence is satisfied (passes the gate). */
+    ok: boolean;
+    /** Substantive Q&A Log row count (excludes `skipped`/`waived` only rows). */
+    count: number;
+    /**
+     * Legacy field, retained for harness UI compatibility. Always 0 in
+     * Wave 23 — the convergence floor no longer enforces a fixed count.
+     * Harness can still surface `questionBudgetHint(track, stage).recommended`
+     * as a soft hint, but it is NOT tied to gate blocking.
+     */
+    min: number;
+    /** Whether a stop-signal row was detected. */
+    hasStopSignal: boolean;
+    /**
+     * Legacy field, retained for harness UI compatibility. Always false in
+     * Wave 23 — convergence semantics replaced the lite-tier short-circuit.
+     */
+    liteShortCircuit: boolean;
+    /** Whether `--skip-questions` flag downgraded the finding to advisory. */
+    skipQuestionsAdvisory: boolean;
+    /** Forcing-question topics deemed addressed (substring match in Q&A). */
+    forcingCovered: string[];
+    /** Forcing-question topics still pending (no matching Q&A row). */
+    forcingPending: string[];
+    /**
+     * True when the last 2 substantive rows have decision_impact marking
+     * `skip`/`continue`/`no-change`/`done`/etc. — i.e. Q&A is no longer
+     * surfacing decision-changing answers (Ralph-Loop convergence detector).
+     */
+    noNewDecisions: boolean;
+    /** Human-readable details for the linter finding. */
+    details: string;
+}
+/**
+ * Extract forcing-question topics from a stage's checklist. Looks for
+ * the canonical `**<Stage> forcing questions (must be covered or
+ * explicitly waived)** — <topic1>, <topic2>, ...` row and tokenizes the
+ * comma-separated topic list. Returns trimmed topic strings stripped of
+ * leading question words (`what`/`who`/`where`/`which`/`how`/`is`/`do`/`does`).
+ *
+ * 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).
+ */
+export declare function extractForcingQuestions(stage: FlowStage): string[];
+/**
+ * Evaluate the Q&A Log convergence floor for a brainstorm / scope /
+ * design artifact. Returns ok=true when convergence is reached or any
+ * escape hatch fires.
+ *
+ * Convergence sources (any one is sufficient):
+ * - All forcing-question topics from the stage checklist appear addressed
+ *   in `## Q&A Log` (substring keyword match in question/answer columns).
+ * - The Ralph-Loop convergence detector reports the last 2 substantive
+ *   rows have decision_impact marking `skip`/`continue`/`no-change`/`done`
+ *   (i.e. the dialogue is no longer producing decision-changing rows).
+ * - Q&A Log contains a stop-signal row (existing
+ *   `QA_LOG_STOP_SIGNAL_PATTERNS` keep working).
+ * - `--skip-questions` flag was persisted to the active stage flags
+ *   (`options.skipQuestions=true`); finding downgrades to advisory.
+ * - The stage checklist exposes no forcing-questions row (e.g. simple
+ *   refactor) AND the artifact has at least one substantive row — treat
+ *   as converged because there is nothing left to force.
+ *
+ * Wave 23 (v5.0.0) replaces the count-based `qa_log_below_min` rule with
+ * `qa_log_unconverged`. The fixed count constant (10 for standard) and
+ * the `CCLAW_ELICITATION_FLOOR=advisory` env override were removed. The
+ * `min` and `liteShortCircuit` fields on the result are retained for
+ * harness UI compatibility but are always 0/false.
+ */
+export declare function evaluateQaLogFloor(qaLogBody: string | null, track: FlowTrack, stage: FlowStage, options?: QaLogFloorOptions): QaLogFloorResult;
 export interface LintFinding {
     section: string;
     required: boolean;
@@ -89,10 +180,6 @@ export declare function canonicalModesInText(text: string): CanonicalScopeMode[]
 export declare function shortModeToCanonical(text: string): CanonicalScopeMode | null;
 export declare function canonicalModeFromCandidate(candidate: string): CanonicalScopeMode | null;
 export declare function extractCanonicalScopeMode(body: string): CanonicalScopeMode | null;
-export declare function validatePremiseChallenge(sectionBody: string): {
-    ok: boolean;
-    details: string;
-};
 export declare function validateScopeSummary(sectionBody: string): {
     ok: boolean;
     details: string;
@@ -116,11 +203,6 @@ export declare function validateRequirementsTaxonomy(sectionBody: string): {
     ok: boolean;
     details: string;
 };
-export declare function validateLockedDecisionAnchors(sectionBody: string): {
-    ok: boolean;
-    anchors: string[];
-    details: string;
-};
 export interface InteractionEdgeCaseRequirement {
     label: string;
     pattern: RegExp;
@@ -220,8 +302,6 @@ export declare const SCOPE_REDUCTION_PATTERNS: Array<{
 export declare function parseFrontmatter(markdown: string): ParsedFrontmatter;
 export declare function extractDecisionIds(text: string): string[];
 export declare function extractRequirementIdsFromMarkdown(text: string): string[];
-export declare function extractLockedDecisionAnchors(text: string): string[];
-export declare function lockedDecisionHash(value: string): string;
 export declare function collectPatternHits(text: string, patterns: Array<{
     label: string;
     regex: RegExp;
@@ -245,4 +325,11 @@ export interface StageLintContext {
     staleDiagramAuditEnabled: boolean;
     isTrivialOverride: boolean;
     overrideSet: Set<string> | null;
+    /**
+     * Stage-level flags persisted to flow-state.json `activeRun.currentStage.flags`
+     * (or equivalent). Used as escape-hatch signal for the Q&A floor rule
+     * (e.g. `--skip-questions` downgrades `qa_log_unconverged` to advisory).
+     * When orchestrator cannot read flow-state, defaults to an empty array.
+     */
+    activeStageFlags: string[];
 }