cclaw-cli 2.0.0 → 4.0.0

package/dist/artifact-linter/brainstorm.js

@@ -1,6 +1,6 @@
 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";
 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 +9,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 +17,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_below_min",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_below_min — Q&A Log below the adaptive elicitation floor for this track. Continue the loop or record an explicit user stop-signal row.",
+            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

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_below_min",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_below_min — Q&A Log below the adaptive elicitation floor for this track. Continue the loop or record an explicit user stop-signal row.",
+            found: floor.ok,
+            details: floor.details
+        });
+    }
     const criticPredictions = checkCriticPredictionsContract(sections);
     if (criticPredictions !== 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_below_min",
+            required: !floor.skipQuestionsAdvisory,
+            rule: "[P1] qa_log_below_min — Q&A Log below the adaptive elicitation floor for this track. Continue the loop or record an explicit user stop-signal row.",
+            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,8 +100,8 @@ 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.`

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

@@ -1,4 +1,45 @@
 import { type FlowStage, type FlowTrack } from "../types.js";
+/**
+ * Stages that run adaptive elicitation. The `qa_log_below_min` rule only
+ * fires for these. Other stages may still record a Q&A Log but no floor is
+ * enforced.
+ */
+export declare const ELICITATION_STAGES: ReadonlySet<FlowStage>;
+export interface QaLogFloorOptions {
+    /**
+     * When true, downgrades a below-floor finding to advisory (`required: false`).
+     * Set when `--skip-questions` was persisted to the active stage flags.
+     */
+    skipQuestions?: boolean;
+}
+export interface QaLogFloorResult {
+    /** Whether the floor is satisfied (passes the gate). */
+    ok: boolean;
+    /** Substantive Q&A Log row count (excludes `skipped`/`waived` only rows). */
+    count: number;
+    /** Required minimum count from `questionBudgetHint(track, stage).min`. */
+    min: number;
+    /** Whether a stop-signal row was detected. */
+    hasStopSignal: boolean;
+    /** Whether the lite-tier short-circuit applies (lite track + count >= 1). */
+    liteShortCircuit: boolean;
+    /** Whether `--skip-questions` flag downgraded the finding to advisory. */
+    skipQuestionsAdvisory: boolean;
+    /** Human-readable details for the linter finding. */
+    details: string;
+}
+/**
+ * Evaluate the Q&A Log floor for a brainstorm / scope / design artifact.
+ * Returns ok=true when the floor is satisfied or any escape hatch fires.
+ *
+ * Escape hatches (any one is sufficient):
+ * - Q&A Log contains a stop-signal row.
+ * - `--skip-questions` flag was persisted to the active stage flags
+ *   (passed via `options.skipQuestions=true`); finding downgrades to advisory.
+ * - Track is `quick` (lite tier ~ lightweight complexity) AND substantive
+ *   count >= 1.
+ */
+export declare function evaluateQaLogFloor(qaLogBody: string | null, track: FlowTrack, stage: FlowStage, options?: QaLogFloorOptions): QaLogFloorResult;
 export interface LintFinding {
     section: string;
     required: boolean;
@@ -116,11 +157,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 +256,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 +279,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_below_min` to advisory).
+     * When orchestrator cannot read flow-state, defaults to an empty array.
+     */
+    activeStageFlags: string[];
 }

package/dist/artifact-linter/shared.js

@@ -1,6 +1,128 @@
-import { createHash } from "node:crypto";
 import { SHIP_FINALIZATION_MODES } from "../constants.js";
+import { questionBudgetHint } from "../track-heuristics.js";
 import { FLOW_STAGES } from "../types.js";
+/**
+ * Recognized stop-signal phrases that satisfy the Q&A floor escape hatch
+ * when recorded as a Q&A Log row. Mirrors `Stop Signals (Natural Language)`
+ * in `adaptive-elicitation/SKILL.md`.
+ */
+/**
+ * Stop-signal phrases. ASCII tokens use `\b` word boundaries; non-ASCII
+ * (RU/UA) tokens use Unicode-aware boundaries built from `\p{L}` so cyrillic
+ * characters around the phrase prevent partial matches without breaking on
+ * `\b`'s ASCII-only boundary semantics.
+ */
+const QA_LOG_STOP_SIGNAL_PATTERNS = [
+    /\bstop[-\s]?signal\b/iu,
+    /\bachieved\s+enough\b/iu,
+    /\benough\b/iu,
+    /\bskip\b/iu,
+    /\bjust\s+draft\s+it\b/iu,
+    /\bstop\s+asking\b/iu,
+    /\bmove\s+on\b/iu,
+    /\bno\s+more\s+questions\b/iu,
+    /(?<![\p{L}\p{N}_])достаточно(?![\p{L}\p{N}_])/iu,
+    /(?<![\p{L}\p{N}_])хватит(?![\p{L}\p{N}_])/iu,
+    /(?<![\p{L}\p{N}_])давай\s+драфт(?![\p{L}\p{N}_])/iu,
+    /(?<![\p{L}\p{N}_])досить(?![\p{L}\p{N}_])/iu,
+    /(?<![\p{L}\p{N}_])вистачить(?![\p{L}\p{N}_])/iu,
+    /(?<![\p{L}\p{N}_])рухаємось\s+далі(?![\p{L}\p{N}_])/iu
+];
+/**
+ * Stages that run adaptive elicitation. The `qa_log_below_min` rule only
+ * fires for these. Other stages may still record a Q&A Log but no floor is
+ * enforced.
+ */
+export const ELICITATION_STAGES = new Set([
+    "brainstorm",
+    "scope",
+    "design"
+]);
+/**
+ * Decide whether a Q&A Log row counts as a "substantive" entry for the floor.
+ * Rows whose disposition column reads `skipped` / `waived` only do not
+ * count toward the minimum.
+ */
+function isSubstantiveQaRow(cells) {
+    if (cells.length === 0)
+        return false;
+    const last = cells[cells.length - 1] ?? "";
+    const normalized = last.toLowerCase();
+    if (/^\s*(?:skipped|waived)\b/u.test(normalized))
+        return false;
+    return true;
+}
+/**
+ * Detect a stop-signal row in the Q&A Log. Pattern is matched across all
+ * cells of any row so the user's quote can live in any column.
+ */
+function detectStopSignal(rows) {
+    for (const row of rows) {
+        const joined = row.join(" | ");
+        for (const pattern of QA_LOG_STOP_SIGNAL_PATTERNS) {
+            if (pattern.test(joined))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Evaluate the Q&A Log floor for a brainstorm / scope / design artifact.
+ * Returns ok=true when the floor is satisfied or any escape hatch fires.
+ *
+ * Escape hatches (any one is sufficient):
+ * - Q&A Log contains a stop-signal row.
+ * - `--skip-questions` flag was persisted to the active stage flags
+ *   (passed via `options.skipQuestions=true`); finding downgrades to advisory.
+ * - Track is `quick` (lite tier ~ lightweight complexity) AND substantive
+ *   count >= 1.
+ */
+export function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
+    const hint = questionBudgetHint(track, stage);
+    const min = hint.min;
+    const rows = qaLogBody !== null ? getMarkdownTableRows(qaLogBody) : [];
+    const substantiveRows = rows.filter(isSubstantiveQaRow);
+    const count = substantiveRows.length;
+    const hasStopSignal = detectStopSignal(rows);
+    const liteShortCircuit = track === "quick" && count >= 1;
+    // Emergency override (undocumented for users): set
+    // `CCLAW_ELICITATION_FLOOR=advisory` to downgrade qa_log_below_min from
+    // blocking to advisory globally. This is a safety net for incidents where
+    // the floor mis-fires across an org; treat as `--skip-questions` semantics.
+    const envOverride = (typeof process !== "undefined" ? process.env?.CCLAW_ELICITATION_FLOOR : undefined) === "advisory";
+    const skipQuestionsAdvisory = options.skipQuestions === true || envOverride;
+    const ok = count >= min || hasStopSignal || liteShortCircuit;
+    let details;
+    if (ok) {
+        if (count >= min) {
+            details = `Q&A Log has ${count} substantive entries (floor for ${track}/${stage}: ${min}).`;
+        }
+        else if (hasStopSignal) {
+            details = `Q&A Log has ${count} substantive entries with an explicit user stop-signal row recorded (floor: ${min}).`;
+        }
+        else {
+            details = `Q&A Log has ${count} substantive entry under lightweight track short-circuit (default floor: ${min}).`;
+        }
+    }
+    else if (skipQuestionsAdvisory) {
+        const reason = options.skipQuestions === true
+            ? "--skip-questions flag was set"
+            : "CCLAW_ELICITATION_FLOOR=advisory env override is active";
+        details = `Q&A Log has ${count} substantive entries, minimum for ${track}/${stage} is ${min}; ${reason}, finding downgraded to advisory.`;
+    }
+    else {
+        details = `Q&A Log has ${count} substantive entries, minimum for ${track}/${stage} is ${min}. Continue the elicitation loop or record an explicit user stop-signal row in Q&A Log.`;
+    }
+    return {
+        ok,
+        count,
+        min,
+        hasStopSignal,
+        liteShortCircuit,
+        skipQuestionsAdvisory,
+        details
+    };
+}
 export function normalizeHeadingTitle(title) {
     return title.trim().replace(/\s+/g, " ");
 }
@@ -786,52 +908,6 @@ export function validateRequirementsTaxonomy(sectionBody) {
         details: "Requirements table uses canonical Priority values."
     };
 }
-export function validateLockedDecisionAnchors(sectionBody) {
-    const rows = getMarkdownTableRows(sectionBody);
-    const lines = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^[-*]\s+\S/u.test(line));
-    const anchors = [];
-    const issues = [];
-    for (const [index, row] of rows.entries()) {
-        const anchor = (row[0] ?? "").trim().toLowerCase();
-        const decisionText = (row[1] ?? "").trim();
-        if (!/^ld#[0-9a-f]{8}$/u.test(anchor)) {
-            issues.push(`row ${index + 1} has invalid anchor "${row[0] ?? ""}"`);
-            continue;
-        }
-        anchors.push(anchor);
-        if (decisionText.length > 0) {
-            const expected = lockedDecisionHash(decisionText).toLowerCase();
-            if (anchor !== expected) {
-                issues.push(`row ${index + 1} anchor should be ${expected} for its Decision text`);
-            }
-        }
-    }
-    for (const [index, line] of lines.entries()) {
-        const anchor = /\bLD#[0-9a-f]{8}\b/iu.exec(line)?.[0]?.toLowerCase();
-        if (!anchor) {
-            issues.push(`bullet ${index + 1} is missing an LD#<sha8> anchor`);
-            continue;
-        }
-        anchors.push(anchor);
-    }
-    const duplicateAnchors = [...new Set(anchors.filter((anchor, index) => anchors.indexOf(anchor) !== index))];
-    if (duplicateAnchors.length > 0) {
-        issues.push(`duplicate anchors: ${duplicateAnchors.join(", ")}`);
-    }
-    if (anchors.length === 0 && (rows.length > 0 || lines.length > 0)) {
-        issues.push("no LD#<sha8> anchors found");
-    }
-    return {
-        ok: issues.length === 0,
-        anchors: [...new Set(anchors)],
-        details: issues.length === 0
-            ? `${anchors.length} LD#hash anchor(s) recorded with no duplicates.`
-            : issues.join("; ")
-    };
-}
 export const INTERACTION_EDGE_CASE_REQUIREMENTS = [
     { label: "double-click", pattern: /\bdouble[\s-]?click\b/iu },
     {
@@ -1356,14 +1432,13 @@ export function extractRequirementIdsFromMarkdown(text) {
     const ids = text.match(/\bR\d+\b/gu) ?? [];
     return [...new Set(ids)];
 }
-export function extractLockedDecisionAnchors(text) {
-    const ids = text.match(/\bLD#[0-9a-f]{8}\b/giu) ?? [];
-    return [...new Set(ids.map((id) => id.replace(/^LD#/iu, "LD#").toLowerCase()))];
-}
-export function lockedDecisionHash(value) {
-    const normalized = value.replace(/\s+/gu, " ").trim().toLowerCase();
-    return `LD#${createHash("sha256").update(normalized).digest("hex").slice(0, 8)}`;
-}
+// `extractLockedDecisionAnchors` was removed in Wave 22 (v4.0.0) along
+// with the LD#<sha8> contract. Cross-stage decision traceability now uses
+// stable D-XX IDs.
+// `lockedDecisionHash` was removed in Wave 22 (v4.0.0) along with the
+// `Locked Decisions Hash Integrity` linter rule. Decision identity now
+// relies on stable D-XX IDs which the agent can edit safely without
+// recomputing content hashes.
 export function collectPatternHits(text, patterns) {
     const hits = [];
     for (const pattern of patterns) {

package/dist/artifact-linter.d.ts

@@ -2,4 +2,14 @@ import type { FlowStage, FlowTrack } from "./types.js";
 import { type LintResult } from "./artifact-linter/shared.js";
 export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, type ReviewVerdictConsistencyResult, type ReviewSecurityNoChangeAttestationResult } from "./artifact-linter/review-army.js";
 export { type LintFinding, type LintResult, type LearningEntryType, type LearningConfidence, type LearningSeverity, type LearningSource, type LearningSeedEntry, type LearningsParseResult, extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
-export declare function lintArtifact(projectRoot: string, stage: FlowStage, track?: FlowTrack): Promise<LintResult>;
+export interface LintArtifactOptions {
+    /**
+     * Stage-level flags supplied by the caller (typically `advance-stage`)
+     * that augment whatever flow-state.json says. Used so the linter sees
+     * `--skip-questions` even before flow-state is updated for the current
+     * stage (advance-stage applies the hint to the successor stage only,
+     * but the linter must respect the current-call intent).
+     */
+    extraStageFlags?: string[];
+}
+export declare function lintArtifact(projectRoot: string, stage: FlowStage, track?: FlowTrack, options?: LintArtifactOptions): Promise<LintResult>;

package/dist/artifact-linter.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
-import { readConfig } from "./config.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
-import { duplicateH2Headings, extractH2Sections, extractLockedDecisionAnchors, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody } from "./artifact-linter/shared.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 { lintBrainstormStage } from "./artifact-linter/brainstorm.js";
 import { lintDesignStage } from "./artifact-linter/design.js";
 import { lintPlanStage } from "./artifact-linter/plan.js";
@@ -21,7 +21,7 @@ const FRONTMATTER_REQUIRED_KEYS = [
     "locked_decisions",
     "inputs_hash"
 ];
-export async function lintArtifact(projectRoot, stage, track = "standard") {
+export async function lintArtifact(projectRoot, stage, track = "standard", options = {}) {
     const schema = stageSchema(stage, track);
     const { absPath: absFile, relPath: relFile } = await resolveStageArtifactPath(stage, {
         projectRoot,
@@ -58,7 +58,6 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
             details: `Duplicate H2 heading(s): ${duplicateHeadings.join(", ")}. Merge edits into the existing heading to avoid split contracts.`
         });
     }
-    const projectConfig = await readConfig(projectRoot);
     const parsedFrontmatter = parseFrontmatter(raw);
     const frontmatterMissingKeys = FRONTMATTER_REQUIRED_KEYS.filter((key) => {
         const value = parsedFrontmatter.values[key];
@@ -97,8 +96,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
     });
     const brainstormShortCircuitBody = stage === "brainstorm" ? sectionBodyByName(sections, "Short-Circuit Decision") : null;
     const brainstormShortCircuitActivated = stage === "brainstorm" && isShortCircuitActivated(brainstormShortCircuitBody);
-    const scopePreAuditEnabled = projectConfig.optInAudits?.scopePreAudit === true;
-    const staleDiagramAuditEnabled = projectConfig.optInAudits?.staleDiagramAudit === true;
+    const scopePreAuditEnabled = true;
+    const staleDiagramAuditEnabled = true;
     const isTrivialOverride = Boolean(schema.trivialOverrideSections &&
         schema.trivialOverrideSections.length > 0 &&
         (/trivial.change|mini.design|escape.hatch/iu.test(raw) ||
@@ -159,6 +158,21 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
             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,
@@ -173,7 +187,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         scopePreAuditEnabled,
         staleDiagramAuditEnabled,
         isTrivialOverride,
-        overrideSet
+        overrideSet,
+        activeStageFlags
     };
     switch (stage) {
         case "brainstorm":
@@ -215,10 +230,9 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
             const requirementsBody = sectionBodyByHeadingPrefix(scopeSections, "Requirements") ?? "";
             const lockedDecisionsBody = sectionBodyByHeadingPrefix(scopeSections, "Locked Decisions") ?? "";
             const requirementIds = extractRequirementIdsFromMarkdown(requirementsBody);
-            const lockedDecisionAnchors = extractLockedDecisionAnchors(lockedDecisionsBody);
+            const decisionIds = Array.from(new Set((lockedDecisionsBody.match(/\bD-\d+\b/giu) ?? []).map((id) => id.toUpperCase())));
             const missingRequirementRefs = requirementIds.filter((id) => !raw.includes(id));
-            const normalizedCurrentRaw = raw.toLowerCase();
-            const missingDecisionRefs = lockedDecisionAnchors.filter((id) => !normalizedCurrentRaw.includes(id));
+            const missingDecisionRefs = decisionIds.filter((id) => !raw.toUpperCase().includes(id));
             findings.push({
                 section: "Scope Requirement Reference Integrity",
                 required: requirementIds.length > 0,
@@ -231,14 +245,14 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
                         : `Missing scope requirement reference(s): ${missingRequirementRefs.join(", ")}.`
             });
             findings.push({
-                section: "Locked Decision Hash Reference Integrity",
-                required: lockedDecisionAnchors.length > 0,
-                rule: "Every LD#hash locked decision anchor from scope must be referenced by downstream artifacts.",
+                section: "Locked Decision Reference Integrity",
+                required: decisionIds.length > 0,
+                rule: "Every D-XX locked decision ID from scope must be referenced by downstream artifacts.",
                 found: missingDecisionRefs.length === 0,
-                details: lockedDecisionAnchors.length === 0
-                    ? "No LD#hash anchors found in scope artifact; reference check skipped."
+                details: decisionIds.length === 0
+                    ? "No D-XX decision IDs found in scope artifact; reference check skipped."
                     : missingDecisionRefs.length === 0
-                        ? `All ${lockedDecisionAnchors.length} locked decision anchor(s) are referenced.`
+                        ? `All ${decisionIds.length} locked decision ID(s) are referenced.`
                         : `Missing locked decision reference(s): ${missingDecisionRefs.join(", ")}.`
             });
         }

package/dist/cli.js

@@ -425,11 +425,8 @@ async function runCommand(parsed, ctx) {
                 info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
             }
             ctx.stdout.write(`${JSON.stringify({
-                track: previewConfig.defaultTrack ?? "standard",
+                track: effectiveTrack ?? "standard",
                 harnesses: previewConfig.harnesses,
-                strictness: previewConfig.strictness ?? "advisory",
-                gitHookGuards: previewConfig.gitHookGuards,
-                languageRulePacks: previewConfig.languageRulePacks,
                 generatedSurfaces: previewSurfaces
             }, null, 2)}\n`);
             return 0;
@@ -444,11 +441,7 @@ async function runCommand(parsed, ctx) {
         }
         const trackNote = effectiveTrack ? ` (track=${effectiveTrack})` : "";
         info(ctx, `Initialized .cclaw runtime and generated harness shims${trackNote}`);
-        // Point new users at the one config surface they might actually flip —
-        // `strictness` and `gitHookGuards` — without overselling the other knobs
-        // (those live behind docs/config.md until someone needs them).
-        info(ctx, "Config: .cclaw/config.yaml (strictness=advisory, gitHookGuards=false).");
-        info(ctx, "Need stricter guards or language rule packs? See docs/config.md.");
+        info(ctx, "Config: .cclaw/config.yaml (harnesses + auto-managed version stamps).");
         await maybeEnableCodexHooksFlag(effectiveHarnesses, parsed, ctx);
         return 0;
     }