cclaw-cli 3.0.0 → 5.0.0

package/dist/artifact-linter/shared.js

@@ -1,6 +1,272 @@
-import { createHash } from "node:crypto";
 import { SHIP_FINALIZATION_MODES } from "../constants.js";
+import { questionBudgetHint } from "../track-heuristics.js";
 import { FLOW_STAGES } from "../types.js";
+import { stageSchema } from "../content/stage-schema.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_unconverged` rule
+ * only fires for these. Other stages may still record a Q&A Log but no
+ * convergence floor is enforced.
+ */
+export const ELICITATION_STAGES = new Set([
+    "brainstorm",
+    "scope",
+    "design"
+]);
+/**
+ * Phrases that mark a Q&A Log row as "no new decision" — used by the
+ * Ralph-Loop convergence detector. When the last 2 substantive rows have
+ * a Decision impact tagged with one of these phrases, convergence has
+ * been reached even if not every forcing question was explicitly
+ * addressed.
+ */
+const QA_LOG_NO_DECISION_TOKENS = [
+    /\bskip(?:ped)?\b/iu,
+    /\bcontinue\b/iu,
+    /\bno[-\s]?change\b/iu,
+    /\bno[-\s]?decision\b/iu,
+    /\bno[-\s]?op\b/iu,
+    /\bnoop\b/iu,
+    /\bdone\b/iu,
+    /\bsame\b/iu,
+    /\bok\b/iu
+];
+/**
+ * Decide whether a Q&A Log row counts as a "substantive" entry. Rows
+ * whose decision_impact column reads `skipped` / `waived` only do not
+ * count.
+ */
+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;
+}
+/**
+ * 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 function extractForcingQuestions(stage) {
+    let checklist;
+    try {
+        checklist = stageSchema(stage).executionModel.checklist;
+    }
+    catch {
+        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)
+            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 [];
+}
+/**
+ * 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.
+ */
+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);
+    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)
+                return true;
+        }
+    }
+    return false;
+}
+function lastTwoRowsAllNoDecision(substantiveRows) {
+    if (substantiveRows.length < 2)
+        return false;
+    const tail = substantiveRows.slice(-2);
+    for (const row of tail) {
+        const decisionImpact = (row[row.length - 1] ?? "").trim();
+        if (decisionImpact.length === 0)
+            return false;
+        const matched = QA_LOG_NO_DECISION_TOKENS.some((pattern) => pattern.test(decisionImpact));
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+/**
+ * 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 function evaluateQaLogFloor(qaLogBody, track, stage, options = {}) {
+    const rows = qaLogBody !== null ? getMarkdownTableRows(qaLogBody) : [];
+    const substantiveRows = rows.filter(isSubstantiveQaRow);
+    const count = substantiveRows.length;
+    const hasStopSignal = detectStopSignal(rows);
+    const skipQuestionsAdvisory = options.skipQuestions === true;
+    const forcingTopics = options.forcingQuestions ?? extractForcingQuestions(stage);
+    const forcingCovered = [];
+    const forcingPending = [];
+    for (const topic of forcingTopics) {
+        if (isTopicAddressed(topic, rows))
+            forcingCovered.push(topic);
+        else
+            forcingPending.push(topic);
+    }
+    const noNewDecisions = lastTwoRowsAllNoDecision(substantiveRows);
+    const allForcingCovered = forcingTopics.length > 0 ? forcingPending.length === 0 : count >= 1;
+    const ok = allForcingCovered || noNewDecisions || hasStopSignal;
+    let details;
+    if (ok) {
+        if (allForcingCovered && forcingTopics.length > 0) {
+            details = `Q&A Log converged: all ${forcingTopics.length} forcing-question topic(s) addressed across ${count} substantive row(s).`;
+        }
+        else if (allForcingCovered) {
+            details = `Q&A Log converged: stage exposes no forcing-questions row and ${count} substantive entry recorded.`;
+        }
+        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).`
+                : " 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}`;
+        }
+        else {
+            details = `Q&A Log converged: explicit user stop-signal row recorded at ${count} row(s).`;
+        }
+    }
+    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)"}.`;
+    }
+    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.`;
+    }
+    // Surface advisory budget hint for harness UI without re-introducing a
+    // blocking count. `recommended` is the soft budget per track/stage.
+    const advisoryBudget = questionBudgetHint(track, stage).recommended;
+    return {
+        ok,
+        count,
+        // Wave 23: floor no longer enforces a count. Surfacing 0 keeps the
+        // QaLogFloorSignal shape stable for harness consumers; harness UIs
+        // may show `recommended` from `questionBudgetHint` separately.
+        min: 0,
+        hasStopSignal,
+        liteShortCircuit: false,
+        skipQuestionsAdvisory,
+        forcingCovered,
+        forcingPending,
+        noNewDecisions,
+        details: advisoryBudget > 0
+            ? `${details} (advisory budget for ${track}/${stage}: ~${advisoryBudget} Q&A turns)`
+            : details
+    };
+}
 export function normalizeHeadingTitle(title) {
     return title.trim().replace(/\s+/g, " ");
 }
@@ -556,61 +822,12 @@ export function extractCanonicalScopeMode(body) {
     }
     return null;
 }
-export function validatePremiseChallenge(sectionBody) {
-    // gstack-style premise challenge requires a real Q/A structure (table or
-    // list), not free-form prose. The validation is *structural* only — we do
-    // NOT keyword-grep for English phrases like "right problem"; authors may
-    // write the questions in any language, and the answers carry the meaning.
-    // The template ships with canonical question labels as scaffolding, but
-    // the linter only enforces that the section actually compares premise
-    // questions to answers.
-    const tableRows = getMarkdownTableRows(sectionBody);
-    const bulletRows = sectionBody
-        .split(/\r?\n/u)
-        .map((line) => line.trim())
-        .filter((line) => /^(?:[-*]|\d+\.)\s+\S/u.test(line));
-    const rowCount = Math.max(tableRows.length, bulletRows.length);
-    if (rowCount < 3) {
-        return {
-            ok: false,
-            details: `Premise Challenge needs at least 3 substantive rows in a table or bullet list. Found ${rowCount}.`
-        };
-    }
-    // For tables, each data row must have at least 2 non-empty cells so the
-    // section is genuinely a premise/answer comparison, not a list of headlines.
-    // For bullet lists, each line must be substantive so we don't accept
-    // placeholders like `- a`; punctuation style and natural language do not
-    // matter.
-    if (tableRows.length >= 3) {
-        const sparseRows = tableRows.filter((row) => {
-            const filledCells = row.filter((cell) => cell.replace(/[\s|]/gu, "").length >= 2);
-            return filledCells.length < 2;
-        });
-        if (sparseRows.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge table rows must populate at least the question and answer columns (no empty answers)."
-            };
-        }
-    }
-    else if (bulletRows.length >= 3) {
-        const sparseBullets = bulletRows.filter((line) => {
-            const cleaned = line.replace(/^[-*\d.\s]+/u, "").replace(/[`*_]/gu, "").trim();
-            const meaningful = cleaned.match(/[\p{L}\p{N}]/gu)?.length ?? 0;
-            return meaningful < 12;
-        });
-        if (sparseBullets.length > 0) {
-            return {
-                ok: false,
-                details: "Premise Challenge bullet list must include at least 3 substantive rows, not placeholders."
-            };
-        }
-    }
-    return {
-        ok: true,
-        details: `Premise Challenge structures ${rowCount} Q/A rows.`
-    };
-}
+// `validatePremiseChallenge` was removed in Wave 23 (v5.0.0). Premise
+// challenge is now owned solely by brainstorm (`## Premise Check`); scope
+// only records `## Premise Drift` when scope-stage Q&A surfaces new
+// evidence that materially changes the brainstorm answer. The drift
+// section is optional and structural-only via the default `validateSectionBody`
+// path (no specialized validator required).
 export function validateScopeSummary(sectionBody) {
     const meaningfulLines = sectionBody
         .split(/\r?\n/)
@@ -786,52 +1003,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 +1527,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) {
@@ -1476,9 +1646,6 @@ export function validateSectionBody(sectionBody, rule, sectionName) {
     if (sectionNameNormalized === "scope summary") {
         return validateScopeSummary(sectionBody);
     }
-    if (sectionNameNormalized === "premise challenge") {
-        return validatePremiseChallenge(sectionBody);
-    }
     if (sectionNameNormalized.startsWith("requirements")) {
         return validateRequirementsTaxonomy(sectionBody);
     }

package/dist/artifact-linter.d.ts

@@ -1,5 +1,15 @@
 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 { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, checkReviewTddNoCrossArtifactDuplication, type ReviewVerdictConsistencyResult, type ReviewSecurityNoChangeAttestationResult, type ReviewTddDuplicationConflict, type ReviewTddDuplicationResult } 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

@@ -2,7 +2,8 @@ import fs from "node:fs/promises";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.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";
@@ -11,7 +12,7 @@ import { lintSpecStage } from "./artifact-linter/spec.js";
 import { lintTddStage } from "./artifact-linter/tdd.js";
 import { lintReviewStage } from "./artifact-linter/review.js";
 import { lintShipStage } from "./artifact-linter/ship.js";
-export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation } from "./artifact-linter/review-army.js";
+export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, checkReviewTddNoCrossArtifactDuplication } from "./artifact-linter/review-army.js";
 export { extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
 const FRONTMATTER_REQUIRED_KEYS = [
     "stage",
@@ -20,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,
@@ -157,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,
@@ -171,7 +187,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
         scopePreAuditEnabled,
         staleDiagramAuditEnabled,
         isTrivialOverride,
-        overrideSet
+        overrideSet,
+        activeStageFlags
     };
     switch (stage) {
         case "brainstorm":
@@ -213,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,
@@ -229,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/content/core-agents.js

@@ -392,7 +392,12 @@ export const CCLAW_AGENTS = [
             "Compatibility: NO_IMPACT / FOUND_<n>",
             "Observability: NO_IMPACT / FOUND_<n>",
             "Security: routed to security-reviewer (always separate)",
-            "For unusually large/high-risk diffs, optional deep-dive context skills may be loaded: `review-perf-lens`, `review-compat-lens`, `review-observability-lens`.",
+            "",
+            "### Companion lens skills (load on-demand, never all-at-once)",
+            "- **review-perf-lens** — load when reviewing code touching hot paths, loops over large data, network/disk I/O, render hot paths, or sub-100ms latency budgets.",
+            "- **review-compat-lens** — load when reviewing code that runs on multiple OS/runtime/browser targets, modifies shared library APIs, or changes serialized payload shapes.",
+            "- **review-observability-lens** — load when reviewing code that adds/removes logging, metrics, traces, error reporting, or audit/compliance signals.",
+            "If none of those triggers apply, do NOT load the lens skills — they are deep-dive context, not default reading.",
             "",
             "For each finding include:",
             "- Severity: `Critical` | `Important` | `Suggestion`",

package/dist/content/examples.js

@@ -4,6 +4,14 @@ const STAGE_EXAMPLES = {
 - Project state: release checks exist but CI/local behavior drifts.
 - Existing anchors: \`scripts/pre-publish.sh\`, \`src/release/\`, incident notes.
 
+## Q&A Log
+
+| Turn | Question | User answer (1-line) | Decision impact |
+| --- | --- | --- | --- |
+| 1 | Block invalid releases or only warn? | Block. | Validation is a hard gate. |
+| 2 | Shared module or script-only patch? | Shared module. | Reuse in CI/local. |
+| 3 | (stop-signal) | "достаточно, давай драфт" | stop-and-draft |
+
 ## Problem Decision Record
 
 - Depth: standard

package/dist/content/hooks.js

@@ -193,7 +193,8 @@ export function cancelRunScript() {
 export function stageCompleteScript() {
     return internalHelperScript("stage-complete", "advance-stage", "Usage: node " + RUNTIME_ROOT + "/hooks/stage-complete.mjs <stage> [--passed=...] [--evidence-json=...] [--waive-delegation=...] [--waiver-reason=...] [--accept-proactive-waiver] [--accept-proactive-waiver-reason=...] [--skip-questions] [--json]", {
         positionalArgName: "stage",
-        positionalArgRequired: true
+        positionalArgRequired: true,
+        defaultQuietEnvVar: "CCLAW_STAGE_COMPLETE_QUIET"
     });
 }
 export function delegationRecordScript() {

package/dist/content/idea.js

@@ -247,7 +247,12 @@ ${frameBullets}
 8. **Write the artifact** at
    \`${IDEA_ARTIFACT_PATTERN}\` using the schema in the skill.
 9. **Present the handoff prompt** with four concrete options - not A/B/C
-   letters. Default = "Start /cc on the top recommendation".
+   letters. Default = "Start /cc on the top recommendation". When the user
+   picks the start option, plumb the chosen candidate forward via
+   \`start-flow --from-idea-artifact=<path> --from-idea-candidate=I-<n>\`
+   (Wave 23 / v5.0.0) so brainstorm reuses the idea's divergent + critique +
+   rank work via \`interactionHints.brainstorm.fromIdeaArtifact\`; do NOT
+   ask brainstorm to regenerate it.
 
 ## Headless mode (CI/automation only)
 
@@ -390,7 +395,14 @@ Required options, in this order:
 ### Phase 6 - Execute the choice
 
 - Start /cc: load \`${RUNTIME_ROOT}/skills/using-cclaw/SKILL.md\` and run
-  \`/cc <phrase>\`.
+  \`/cc <phrase>\`. **Wave 23 (v5.0.0) handoff carry-forward (mandatory when starting from /cc-idea):**
+  the harness shim that turns \`/cc <phrase>\` into a \`start-flow\` invocation
+  MUST forward the originating idea artifact and chosen candidate so brainstorm
+  reuses divergent + critique + rank work instead of redoing it. Equivalent CLI
+  call (used by automation; harness handles this transparently in interactive mode):
+  \`npx cclaw-cli internal start-flow --track=<track> --prompt='<phrase>' --from-idea-artifact=${IDEA_ARTIFACT_PATTERN} --from-idea-candidate=I-<n>\`.
+  The hint lands in \`flow-state.interactionHints.brainstorm\` and brainstorm's
+  \`Idea-evidence carry-forward\` checklist row picks it up.
 - Save and close: reply with artifact path and stop.
 - Discard: delete the artifact and stop.
 

package/dist/content/review-prompts.js

@@ -53,7 +53,7 @@ value. Do not nitpick wording.
 | 10-star delta | Is there a better high-leverage scope move worth cherry-picking? |
 | Boundary | Are accepted, deferred, and excluded items unambiguous? |
 | Mode fit | Does the selected mode match the evidence: SCOPE EXPANSION, SELECTIVE EXPANSION, HOLD SCOPE, or SCOPE REDUCTION? |
-| Downstream refs | Are R-IDs and LD#hash anchors ready for design/spec/plan? |
+| Downstream refs | Are R-IDs and D-XX decision IDs ready for design/spec/plan? |
 
 ## Output
 
@@ -82,7 +82,7 @@ rework, missing failure behavior, or unverifiable acceptance criteria.
 | Architecture | Are component boundaries concrete and aligned with scope? |
 | Data flow | Are inputs, outputs, persistence, and async/sync edges explicit? |
 | Failure modes | Does every meaningful failure have detection, rescue, and user-visible behavior? |
-| Traceability | Do design decisions reference relevant R-IDs and LD#hash anchors? |
+| Traceability | Do design decisions reference relevant R-IDs and D-XX decision IDs? |
 | Verification | Is each risky choice testable by spec/plan/TDD? |
 | Overbuild | Is any architecture stronger than the locked scope actually needs? |
 
@@ -95,7 +95,7 @@ Record findings in the design artifact's review section:
 **Status:** Approved | Issues Found
 
 **Issues:**
-- [R#/LD#hash]: <specific issue> — <why it matters>
+- [R#/D-XX]: <specific issue> — <why it matters>
 
 **Recommendations:**
 - <advisory item or None>