cclaw-cli 4.0.0 → 6.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, 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");
@@ -21,9 +22,9 @@ export async function lintBrainstormStage(ctx) {
         const skipQuestions = ctx.activeStageFlags.includes("--skip-questions");
         const floor = evaluateQaLogFloor(qaLogBody, track, "brainstorm", { skipQuestions });
         findings.push({
-            section: "qa_log_below_min",
+            section: "qa_log_unconverged",
             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.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, 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
         });
@@ -279,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

@@ -222,9 +222,9 @@ export async function lintDesignStage(ctx) {
         const skipQuestions = activeStageFlags.includes("--skip-questions");
         const floor = evaluateQaLogFloor(qaLogBody, track, "design", { skipQuestions });
         findings.push({
-            section: "qa_log_below_min",
+            section: "qa_log_unconverged",
             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.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, 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
         });

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

@@ -23,9 +23,9 @@ export async function lintScopeStage(ctx) {
         const skipQuestions = activeStageFlags.includes("--skip-questions");
         const floor = evaluateQaLogFloor(qaLogBody, track, "scope", { skipQuestions });
         findings.push({
-            section: "qa_log_below_min",
+            section: "qa_log_unconverged",
             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.",
+            rule: "[P1] qa_log_unconverged — Q&A Log has not converged for this stage. Continue elicitation until every forcing-question topic id is tagged with `[topic:<id>]` on at least one row, 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
         });
@@ -108,19 +108,11 @@ export async function lintScopeStage(ctx) {
                 : 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,43 +1,121 @@
 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.
+ * 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>;
+/**
+ * Wave 24 (v6.0.0) — language-neutral forcing-question topic descriptor.
+ *
+ * Each forcing-question row in a stage's checklist now declares topics as
+ * `id: human-readable label` pairs (e.g. `pain: what pain are we solving`).
+ * The `id` (kebab-case ASCII) is the machine-key authors stamp on Q&A Log
+ * rows via `[topic:<id>]` so the linter can verify coverage in ANY natural
+ * language (RU/EN/UA/etc.). Wave 23's English keyword fallback was removed
+ * because it silently mis-reported convergence on RU/UA Q&A.
+ */
+export interface ForcingQuestionTopic {
+    id: string;
+    topic: string;
+}
 export interface QaLogFloorOptions {
     /**
-     * When true, downgrades a below-floor finding to advisory (`required: false`).
+     * 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 topic descriptors. When
+     * omitted, the evaluator calls `extractForcingQuestions(stage)` which
+     * scans the stage's checklist row. Strings are accepted as topic IDs
+     * (label = id) for callers that build their own list.
+     */
+    forcingQuestions?: ReadonlyArray<ForcingQuestionTopic | string>;
 }
 export interface QaLogFloorResult {
-    /** Whether the floor is satisfied (passes the gate). */
+    /** Whether convergence 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`. */
+    /**
+     * 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;
-    /** Whether the lite-tier short-circuit applies (lite track + count >= 1). */
+    /**
+     * 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;
 }
 /**
- * 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.
+ * Parse a single checklist row into the list of forcing-question topic
+ * descriptors it declares. Returns `null` when the row is not a
+ * forcing-questions header. Throws when the header is found but its
+ * body does not match the Wave 24 `id: topic; id: topic; ...` syntax
+ * — authors fix the stage definition rather than silently ship
+ * un-coverable topics.
  *
- * Escape hatches (any one is sufficient):
- * - Q&A Log contains a stop-signal row.
+ * Exposed for unit tests that exercise the parser without depending on
+ * the live stage schema.
+ */
+export declare function parseForcingQuestionsRow(row: string, context?: string): ForcingQuestionTopic[] | null;
+/**
+ * Extract forcing-question topics from a stage's checklist.
+ *
+ * Wave 24 (v6.0.0): only the new `id: topic; id: topic; ...` syntax is
+ * accepted. Throws when the syntax is malformed so authors fix the
+ * stage definition rather than silently shipping un-coverable topics.
+ *
+ * Returns empty array when no forcing-questions row is present (caller
+ * treats absence as "no forcing requirement" — convergence falls back
+ * to the no-new-decisions / stop-signal detectors). Returning [] when
+ * the row exists but lists no segments is also legal.
+ */
+export declare function extractForcingQuestions(stage: FlowStage): ForcingQuestionTopic[];
+/**
+ * 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
- *   (passed via `options.skipQuestions=true`); finding downgrades to advisory.
- * - Track is `quick` (lite tier ~ lightweight complexity) AND substantive
- *   count >= 1.
+ *   (`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 {
@@ -130,10 +208,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;
@@ -282,7 +356,7 @@ export interface StageLintContext {
     /**
      * 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).
+     * (e.g. `--skip-questions` downgrades `qa_log_unconverged` to advisory).
      * When orchestrator cannot read flow-state, defaults to an empty array.
      */
     activeStageFlags: string[];