cclaw-cli 0.47.0 → 0.48.1

package/dist/content/stage-schema.js

@@ -1,7 +1,18 @@
-import { COMMAND_FILE_ORDER } from "../constants.js";
-import { FLOW_TRACKS, TRACK_STAGES } from "../types.js";
+import { FLOW_STAGES, FLOW_TRACKS, TRACK_STAGES } from "../types.js";
+import { STAGE_TO_SKILL_FOLDER } from "../constants.js";
 import { BRAINSTORM, SCOPE, DESIGN, SPEC, PLAN, TDD, REVIEW, SHIP } from "./stages/index.js";
 import { tddStageForTrack } from "./stages/tdd.js";
+const ARTIFACT_STAGE_BY_PATH = {
+    ".cclaw/artifacts/01-brainstorm.md": "brainstorm",
+    ".cclaw/artifacts/02-scope.md": "scope",
+    ".cclaw/artifacts/02a-research.md": "design",
+    ".cclaw/artifacts/03-design.md": "design",
+    ".cclaw/artifacts/04-spec.md": "spec",
+    ".cclaw/artifacts/05-plan.md": "plan",
+    ".cclaw/artifacts/06-tdd.md": "tdd",
+    ".cclaw/artifacts/07-review.md": "review",
+    ".cclaw/artifacts/08-ship.md": "ship"
+};
 const REQUIRED_GATE_IDS = {
     brainstorm: [
         "brainstorm_approaches_compared",
@@ -36,6 +47,7 @@ const REQUIRED_GATE_IDS = {
         "tdd_green_full_suite",
         "tdd_refactor_completed",
         "tdd_verified_before_complete",
+        "tdd_docs_drift_check",
         ...(track === "quick" ? [] : ["tdd_traceable_to_plan"])
     ],
     review: (track) => [
@@ -92,6 +104,16 @@ function tieredArtifactValidation(stage, rows) {
         };
     });
 }
+function readsFromForTrack(readsFrom, track) {
+    const stageSet = new Set(TRACK_STAGES[track]);
+    return readsFrom.filter((artifactPath) => {
+        const stage = ARTIFACT_STAGE_BY_PATH[artifactPath];
+        if (!stage) {
+            return true;
+        }
+        return stageSet.has(stage);
+    });
+}
 // ---------------------------------------------------------------------------
 // Stage map and accessors
 // ---------------------------------------------------------------------------
@@ -199,8 +221,8 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         },
         {
             agent: "reviewer",
-            mode: "proactive",
-            when: "When the diff exceeds 100 changed lines, touches more than 10 files, or modifies trust boundaries — dispatch a SECOND, independent reviewer with the adversarial-review skill loaded so the review army has at least two voices on a high-blast-radius change.",
+            mode: "mandatory",
+            when: "Mandatory when the diff exceeds 100 changed lines, touches more than 10 files, or modifies trust boundaries — dispatch a SECOND, independent reviewer with the adversarial-review skill loaded so the review army has at least two voices on a high-blast-radius change.",
             purpose: "Adversarial second-opinion review on large or trust-sensitive diffs. The second reviewer treats the implementation as hostile and tries to break it (hostile-user, future-maintainer, competitor lenses) instead of sympathetically explaining it.",
             requiresUserGate: false,
             skill: "adversarial-review"
@@ -233,23 +255,29 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
 };
 /** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
 export function mandatoryDelegationsForStage(stage) {
-    return STAGE_AUTO_SUBAGENT_DISPATCH[stage]
-        .filter((d) => d.mode === "mandatory")
-        .map((d) => d.agent);
+    return [...new Set(STAGE_AUTO_SUBAGENT_DISPATCH[stage]
+            .filter((d) => d.mode === "mandatory")
+            .map((d) => d.agent))];
 }
 export function stageSchema(stage, track = "standard") {
     const base = stage === "tdd" ? tddStageForTrack(track) : STAGE_SCHEMA_MAP[stage];
     const tieredGates = tieredStageGates(stage, base.requiredGates, track);
     const tieredValidation = tieredArtifactValidation(stage, base.artifactValidation);
+    const crossStageTrace = {
+        ...base.crossStageTrace,
+        readsFrom: readsFromForTrack(base.crossStageTrace.readsFrom, track)
+    };
     return {
         ...base,
+        skillFolder: STAGE_TO_SKILL_FOLDER[stage],
+        crossStageTrace,
         requiredGates: tieredGates,
         artifactValidation: tieredValidation,
         mandatoryDelegations: mandatoryDelegationsForStage(stage)
     };
 }
 export function orderedStageSchemas(track = "standard") {
-    return COMMAND_FILE_ORDER.map((stage) => stageSchema(stage, track));
+    return FLOW_STAGES.map((stage) => stageSchema(stage, track));
 }
 export function stageGateIds(stage, track = "standard") {
     return stageSchema(stage, track).requiredGates

package/dist/content/stages/design.js

@@ -10,7 +10,7 @@ export const DESIGN = {
     ironLaw: "NO DESIGN DECISION WITHOUT A LABELED DIAGRAM, A REJECTED ALTERNATIVE, AND A NAMED FAILURE MODE.",
     purpose: "Lock architecture, data flow, failure modes, and test/performance expectations through rigorous interactive review.",
     whenToUse: [
-        "After scope contract approval",
+        "After scope agreement approval",
         "Before writing final spec and execution plan",
         "When architecture risks need explicit treatment"
     ],
@@ -79,7 +79,7 @@ export const DESIGN = {
         "What-already-exists section produced.",
         "Completion dashboard lists every review section status, decision count, and unresolved items (or 'None')."
     ],
-    inputs: ["scope contract", "system constraints", "non-functional requirements"],
+    inputs: ["scope agreement artifact", "system constraints", "non-functional requirements"],
     requiredContext: [
         "parallel research synthesis from `.cclaw/artifacts/02a-research.md`",
         "existing architecture and boundaries",

package/dist/content/stages/review.js

@@ -201,7 +201,7 @@ export const REVIEW = {
     },
     artifactValidation: [
         { section: "Layer 1 Verdict", required: true, validationRule: "Per-criterion pass/fail with references." },
-        { section: "Layer 2 Findings", required: false, validationRule: "Each finding has severity, description, and resolution status." },
+        { section: "Layer 2 Findings", required: false, validationRule: "Each finding has severity, description, and resolution status. Security coverage must include either explicit security findings or `NO_CHANGE_ATTESTATION: <reason>` when no security-relevant changes were found." },
         { section: "Review Army Contract", required: true, validationRule: "Structured findings include id/severity/confidence/fingerprint/reportedBy/status with dedup reconciliation summary." },
         { section: "Review Readiness Dashboard", required: false, validationRule: "Includes a per-pass table (Layer 1 / Layer 2 / Adversarial / Schema) with a 'Completed at' column, a Delegation log snapshot block (path .cclaw/state/delegation-log.json with required/completed/waived/pending), a Staleness signal block (commit at last review pass and current commit), and a Headline with open critical blockers + ship recommendation. At minimum, the section text must contain the substrings 'Completed at', 'delegation-log.json', 'commit at last review pass', and 'Ship recommendation'." },
         { section: "Completeness Score", required: false, validationRule: "Records AC coverage, task coverage, test-slice coverage, and adversarial-review pass status as numeric or boolean values. At minimum, a line like 'AC coverage: N/M' or 'AC coverage: 100%'." },

package/dist/content/stages/ship.js

@@ -100,6 +100,8 @@ export const SHIP = {
         "FINALIZE_NO_VCS"
     ],
     artifactFile: "08-ship.md",
+    // `done` exits the stage pipeline. Archive semantics are handled by the
+    // closeout substate machine (`idle` -> ... -> `archived`) in flow-state.
     next: "done",
     reviewSections: [
         {

package/dist/content/stages/tdd.js

@@ -63,7 +63,8 @@ export const TDD = {
         { id: "tdd_green_full_suite", description: "Full relevant suite passes in GREEN state." },
         { id: "tdd_refactor_completed", description: "Refactor pass completed with behavior preservation verified." },
         { id: "tdd_verified_before_complete", description: "Fresh verification evidence includes test command, commit SHA, and explicit pass/fail status." },
-        { id: "tdd_traceable_to_plan", description: "Change traceability to plan slice is explicit." }
+        { id: "tdd_traceable_to_plan", description: "Change traceability to plan slice is explicit." },
+        { id: "tdd_docs_drift_check", description: "When public API/config/CLI surfaces change, docs drift is addressed via a completed doc-updater pass." }
     ],
     requiredEvidence: [
         "Artifact updated at `.cclaw/artifacts/06-tdd.md` with RED, GREEN, and REFACTOR sections.",
@@ -206,9 +207,12 @@ function tddQuickTrackVariant() {
         checklist: TDD.checklist.map(quickTrackText),
         interactionProtocol: TDD.interactionProtocol.map(quickTrackText),
         process: TDD.process.map(quickTrackText),
-        requiredGates: TDD.requiredGates.map((gate) => gate.id === "tdd_traceable_to_plan"
-            ? { ...gate, description: "Change traceability to acceptance criterion is explicit." }
-            : gate),
+        requiredGates: TDD.requiredGates
+            .filter((gate) => gate.id !== "tdd_traceable_to_plan")
+            .map((gate) => ({
+            ...gate,
+            description: quickTrackText(gate.description)
+        })),
         requiredEvidence: TDD.requiredEvidence.map(quickTrackText),
         inputs: TDD.inputs.map(quickTrackText),
         requiredContext: ["spec artifact", "existing test patterns"],

package/dist/content/templates.js

@@ -1,10 +1,11 @@
-import { COMMAND_FILE_ORDER } from "../constants.js";
+import { CCLAW_VERSION } from "../constants.js";
 import { orderedStageSchemas } from "./stage-schema.js";
+import { FLOW_STAGES } from "../types.js";
 export const ARTIFACT_TEMPLATES = {
     "01-brainstorm.md": `---
 stage: brainstorm
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -52,7 +53,7 @@ inputs_hash: sha256:pending
     "02-scope.md": `---
 stage: scope
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -158,7 +159,7 @@ inputs_hash: sha256:pending
     "02a-research.md": `---
 stage: design
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -199,7 +200,7 @@ inputs_hash: sha256:pending
     "03-design.md": `---
 stage: design
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -303,7 +304,7 @@ inputs_hash: sha256:pending
     "04-spec.md": `---
 stage: spec
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -359,7 +360,7 @@ inputs_hash: sha256:pending
     "05-plan.md": `---
 stage: plan
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -438,7 +439,7 @@ Execution rule: complete and verify each batch before starting the next batch.
     "06-tdd.md": `---
 stage: tdd
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -505,7 +506,7 @@ inputs_hash: sha256:pending
     "07-review.md": `---
 stage: review
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -522,6 +523,7 @@ inputs_hash: sha256:pending
 | ID | Severity | Category | Description | Status |
 |---|---|---|---|---|
 | R-1 | Critical/Important/Suggestion | correctness/security/performance/architecture |  | open/resolved |
+- NO_CHANGE_ATTESTATION: <required when Category=security has no entries; explain why no security-relevant changes were detected>
 
 ## Incoming Feedback Queue
 | ID | Source | Severity | File:line | Request | Status | Evidence |
@@ -613,7 +615,7 @@ inputs_hash: sha256:pending
     "08-ship.md": `---
 stage: ship
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -668,7 +670,7 @@ inputs_hash: sha256:pending
     "09-retro.md": `---
 stage: retro
 schema_version: 1
-version: 0.18.0
+version: ${CCLAW_VERSION}
 feature: <feature-id>
 locked_decisions: []
 inputs_hash: sha256:pending
@@ -802,7 +804,7 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 export function buildRulesJson() {
     return {
         version: 1,
-        stage_order: COMMAND_FILE_ORDER,
+        stage_order: FLOW_STAGES,
         stage_gates: Object.fromEntries(orderedStageSchemas().map((schema) => [
             schema.stage,
             schema.requiredGates.map((gate) => gate.id)
@@ -820,7 +822,7 @@ export function buildRulesJson() {
             "conventional_commits"
         ],
         MUST_NEVER: [
-            "skip_test_stage",
+            "skip_tdd_stage",
             "ship_with_critical_findings",
             "implement_in_brainstorm",
             "manual_edit_generated",

package/dist/content/utility-skills.d.ts

@@ -48,4 +48,10 @@ export declare const LANGUAGE_RULE_PACK_GENERATORS: Record<string, () => string>
  */
 export declare const LEGACY_LANGUAGE_RULE_PACK_FOLDERS: readonly ["language-typescript", "language-python", "language-go"];
 export declare const UTILITY_SKILL_FOLDERS: readonly ["security", "debugging", "performance", "ci-cd", "docs", "executing-plans", "verification-before-completion", "finishing-a-development-branch", "context-engineering", "source-driven-development", "frontend-accessibility", "landscape-check", "adversarial-review", "security-audit", "knowledge-curation", "retrospective", "document-review", "receiving-code-review"];
-export declare const UTILITY_SKILL_MAP: Record<string, () => string>;
+export type UtilitySkillFolder = (typeof UTILITY_SKILL_FOLDERS)[number];
+/**
+ * One entry per `UTILITY_SKILL_FOLDERS` slot. Typed via the tuple so that
+ * adding a folder without a generator (or vice versa) is a TypeScript
+ * error — keeps the two sources of truth in lockstep at compile time.
+ */
+export declare const UTILITY_SKILL_MAP: Record<UtilitySkillFolder, () => string>;

package/dist/content/utility-skills.js

@@ -1735,6 +1735,11 @@ export const UTILITY_SKILL_FOLDERS = [
     "document-review",
     "receiving-code-review"
 ];
+/**
+ * One entry per `UTILITY_SKILL_FOLDERS` slot. Typed via the tuple so that
+ * adding a folder without a generator (or vice versa) is a TypeScript
+ * error — keeps the two sources of truth in lockstep at compile time.
+ */
 export const UTILITY_SKILL_MAP = {
     security: securityReviewSkill,
     debugging: debuggingSkill,

package/dist/delegation.d.ts

@@ -66,6 +66,16 @@ export type DelegationLedger = {
     runId: string;
     entries: DelegationEntry[];
 };
+/**
+ * Heuristic: does a changed file path strongly imply a trust-boundary
+ * surface? Used to gate adversarial-reviewer requirements on review.
+ *
+ * Matches authN/Z, credentials, crypto, policy, or explicit sanitization
+ * or injection handling. Intentionally excludes broad terms like `input`
+ * and `validation` because they match innocuous paths such as
+ * `form-input.ts` or `number-validation.ts` and produce false positives.
+ */
+export declare function isTrustBoundaryPath(filePath: string): boolean;
 export declare function readDelegationLedger(projectRoot: string): Promise<DelegationLedger>;
 export declare function appendDelegation(projectRoot: string, entry: DelegationEntry): Promise<void>;
 /**

package/dist/delegation.js

@@ -1,11 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { RUNTIME_ROOT } from "./constants.js";
 import { readConfig } from "./config.js";
 import { exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { readFlowState } from "./runs.js";
 import { stageSchema } from "./content/stage-schema.js";
+const execFileAsync = promisify(execFile);
 function delegationLogPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", "delegation-log.json");
 }
@@ -15,6 +18,94 @@ function delegationLockPath(projectRoot) {
 function createSpanId() {
     return `dspan-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
+async function resolveReviewDiffBase(projectRoot) {
+    let head = "";
+    try {
+        head = (await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: projectRoot })).stdout.trim();
+    }
+    catch {
+        return null;
+    }
+    const candidates = ["origin/main", "origin/master", "main", "master"];
+    for (const candidate of candidates) {
+        try {
+            await execFileAsync("git", ["rev-parse", "--verify", candidate], { cwd: projectRoot });
+            const { stdout } = await execFileAsync("git", ["merge-base", "HEAD", candidate], {
+                cwd: projectRoot
+            });
+            const base = stdout.trim();
+            if (base.length > 0 && base !== head) {
+                return base;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD~1"], {
+            cwd: projectRoot
+        });
+        const base = stdout.trim();
+        return base.length > 0 ? base : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Heuristic: does a changed file path strongly imply a trust-boundary
+ * surface? Used to gate adversarial-reviewer requirements on review.
+ *
+ * Matches authN/Z, credentials, crypto, policy, or explicit sanitization
+ * or injection handling. Intentionally excludes broad terms like `input`
+ * and `validation` because they match innocuous paths such as
+ * `form-input.ts` or `number-validation.ts` and produce false positives.
+ */
+export function isTrustBoundaryPath(filePath) {
+    return /(auth|security|secret|token|credential|permission|acl|policy|oauth|session|encrypt|decrypt|sanitize|untrusted|csrf|xss|injection|taint)/iu.test(filePath);
+}
+async function detectReviewTriggers(projectRoot) {
+    const empty = {
+        changedFiles: 0,
+        changedLines: 0,
+        trustBoundaryChanged: false,
+        requireAdversarialReviewer: false
+    };
+    const base = await resolveReviewDiffBase(projectRoot);
+    if (!base) {
+        return empty;
+    }
+    try {
+        const range = `${base}..HEAD`;
+        const shortstat = await execFileAsync("git", ["diff", "--shortstat", range], {
+            cwd: projectRoot
+        });
+        const short = shortstat.stdout.trim();
+        const changedFiles = Number((/(\d+)\s+files?\s+changed/u.exec(short)?.[1] ?? "0"));
+        const insertions = Number((/(\d+)\s+insertions?\(\+\)/u.exec(short)?.[1] ?? "0"));
+        const deletions = Number((/(\d+)\s+deletions?\(-\)/u.exec(short)?.[1] ?? "0"));
+        const changedLines = insertions + deletions;
+        const names = await execFileAsync("git", ["diff", "--name-only", range], {
+            cwd: projectRoot
+        });
+        const changedPaths = names.stdout
+            .split(/\r?\n/gu)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        const trustBoundaryChanged = changedPaths.some((p) => isTrustBoundaryPath(p));
+        const requireAdversarialReviewer = changedLines > 100 || changedFiles > 10 || trustBoundaryChanged;
+        return {
+            changedFiles,
+            changedLines,
+            trustBoundaryChanged,
+            requireAdversarialReviewer
+        };
+    }
+    catch {
+        return empty;
+    }
+}
 function isDelegationTokenUsage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
@@ -76,6 +167,8 @@ function parseLedger(raw, runId) {
         for (const item of entriesRaw) {
             if (isDelegationEntry(item)) {
                 const ts = item.startTs ?? item.ts ?? new Date().toISOString();
+                const inferredFulfillmentMode = item.fulfillmentMode
+                    ?? (item.status === "completed" ? "isolated" : undefined);
                 entries.push({
                     ...item,
                     spanId: item.spanId ?? createSpanId(),
@@ -85,6 +178,7 @@ function parseLedger(raw, runId) {
                         ? item.retryCount
                         : 0,
                     evidenceRefs: Array.isArray(item.evidenceRefs) ? item.evidenceRefs : [],
+                    fulfillmentMode: inferredFulfillmentMode,
                     schemaVersion: 1
                 });
             }
@@ -126,6 +220,12 @@ export async function appendDelegation(projectRoot, entry) {
         if (!Array.isArray(stamped.evidenceRefs)) {
             stamped.evidenceRefs = [];
         }
+        if (stamped.status === "completed" && stamped.fulfillmentMode === undefined) {
+            const config = await readConfig(projectRoot).catch(() => null);
+            const harnesses = config?.harnesses ?? [];
+            const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
+            stamped.fulfillmentMode = expectedFulfillmentMode(fallbacks);
+        }
         // Idempotency: if a caller (or a retried hook) tries to append a row
         // with a spanId that already exists in the ledger, treat it as a no-op
         // instead of growing the log with duplicate entries that subsequent
@@ -174,51 +274,29 @@ export async function checkMandatoryDelegations(projectRoot, stage) {
     const harnesses = config?.harnesses ?? [];
     const fallbacks = harnesses.map((h) => HARNESS_ADAPTERS[h].capabilities.subagentFallback);
     const expectedMode = expectedFulfillmentMode(fallbacks);
-    const onlyWaiverFallback = harnesses.length > 0 && fallbacks.every((f) => f === "waiver");
+    const reviewTriggers = stage === "review" ? await detectReviewTriggers(projectRoot) : null;
     for (const agent of mandatory) {
         const rows = forRun.filter((e) => e.agent === agent);
         const completedRows = rows.filter((e) => e.status === "completed");
         const waivedRows = rows.filter((e) => e.status === "waived");
-        const hasCompleted = completedRows.length > 0;
+        const requiredCompletedCount = stage === "review" &&
+            agent === "reviewer" &&
+            reviewTriggers?.requireAdversarialReviewer
+            ? 2
+            : 1;
+        const hasCompleted = completedRows.length >= requiredCompletedCount;
         const hasWaived = waivedRows.length > 0;
         const ok = hasCompleted || hasWaived;
         if (!ok) {
-            if (onlyWaiverFallback) {
-                const existingHarnessWaiver = rows.some((e) => e.status === "waived" && e.waiverReason === "harness_limitation");
-                if (!existingHarnessWaiver) {
-                    await appendDelegation(projectRoot, {
-                        stage,
-                        agent,
-                        mode: "mandatory",
-                        status: "waived",
-                        waiverReason: "harness_limitation",
-                        fulfillmentMode: "harness-waiver",
-                        ts: new Date().toISOString(),
-                        runId: activeRunId
-                    });
-                }
-                waived.push(agent);
-                autoWaived.push(agent);
-            }
-            else {
-                missing.push(agent);
-            }
+            missing.push(agent);
             continue;
         }
         if (hasWaived) {
             waived.push(agent);
         }
-        // Evidence gating for `completed` rows has two triggers:
-        //   1. The aggregate expected mode is role-switch (no isolated harness
-        //      available), so every completion implicitly ran as role-switch.
-        //   2. Any completed row is explicitly stamped `fulfillmentMode:
-        //      "role-switch"` — even in a mixed install. This closes the loop
-        //      where a Codex session logs a role-switch completion inside a
-        //      claude+codex project: the aggregate expectedMode is "isolated"
-        //      (claude wins), so the role-switch row would previously sail
-        //      through without evidenceRefs.
-        const hasExplicitRoleSwitchRow = completedRows.some((e) => e.fulfillmentMode === "role-switch");
-        const evidenceRequired = expectedMode === "role-switch" || hasExplicitRoleSwitchRow;
+        // Evidence is required for any non-isolated completion mode. Legacy rows
+        // without fulfillmentMode are inferred to `isolated` during parse.
+        const evidenceRequired = completedRows.some((e) => (e.fulfillmentMode ?? "isolated") !== "isolated");
         if (hasCompleted &&
             evidenceRequired &&
             !completedRows.some((e) => Array.isArray(e.evidenceRefs) && e.evidenceRefs.length > 0)) {