canon-ai 3.3.0 → 3.4.0

package/dist/orchestrator/run-task.js

@@ -79,12 +79,12 @@ import { pathToFileURL } from "url";
 
 // src/orchestrator/main.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import fs20 from "fs";
+import fs21 from "fs";
 import os from "os";
 import path20 from "path";
 
 // src/orchestrator/phases/code-review.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 
 // src/orchestrator/cli.ts
@@ -313,6 +313,7 @@ function isSynchronousMode(args) {
 
 // src/orchestrator/git.ts
 import { spawnSync as spawnSync3 } from "child_process";
+import fs6 from "fs";
 import path5 from "path";
 
 // src/orchestrator/env.ts
@@ -1329,6 +1330,23 @@ function filterGitIgnoredPaths(paths, cwd) {
   const stdout = result.stdout ?? "";
   return new Set(stdout.split("\0").filter((p) => p.length > 0));
 }
+function filterStageablePaths(paths, cwd) {
+  if (paths.length === 0) return [];
+  return paths.filter((candidate) => {
+    const probe = spawnSync3("git", ["ls-files", "--error-unmatch", "--", candidate], {
+      cwd,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    if (probe.error || probe.status !== 1) return true;
+    try {
+      fs6.lstatSync(path5.join(cwd, candidate));
+      return true;
+    } catch (error) {
+      const code = error.code;
+      return code !== "ENOENT" && code !== "ENOTDIR";
+    }
+  });
+}
 function commitTaskArtifactsToBase(taskIds, _artifactFiles) {
   void _artifactFiles;
   for (const taskId of taskIds) {
@@ -1410,7 +1428,10 @@ function truncateUtf8(input, capBytes) {
   return bytes.subarray(0, end).toString("utf8");
 }
 function getScopedDiff(baseBranch, cwd, capBytes = 5e4) {
-  const result = gitSafeAtRaw(cwd, "diff", `${baseBranch}...HEAD`);
+  return getScopedDiffInRange(`${baseBranch}...HEAD`, cwd, capBytes);
+}
+function getScopedDiffInRange(rangeExpr, cwd, capBytes = 5e4) {
+  const result = gitSafeAtRaw(cwd, "diff", rangeExpr);
   if (!result.ok) return null;
   const raw = result.stdout;
   if (Buffer.byteLength(raw, "utf8") <= capBytes) {
@@ -1574,10 +1595,34 @@ function parseNameStatusOutput(raw) {
   return [...paths].sort();
 }
 function getAffectedFiles(baseRef, cwd) {
-  const result = gitSafeAtRaw(cwd, "diff", `${baseRef}...HEAD`, "--name-status", "-M", "-z");
-  if (!result.ok || !result.stdout) return [];
+  return getPathsInRange(`${baseRef}...HEAD`, cwd) ?? [];
+}
+function getPathsInRange(rangeExpr, cwd) {
+  const result = gitSafeAtRaw(cwd, "diff", rangeExpr, "--name-status", "-M", "-z");
+  if (!result.ok) return null;
+  if (!result.stdout) return [];
   return parseNameStatusOutput(result.stdout);
 }
+function resolveCommit(ref, cwd) {
+  const result = gitSafeAt(cwd, "rev-parse", "--verify", `${ref}^{commit}`);
+  return result.ok ? result.stdout.trim() : null;
+}
+function isAncestorCommit(ancestorRef, descendantRef, cwd) {
+  return gitSafeAt(cwd, "merge-base", "--is-ancestor", ancestorRef, descendantRef).ok;
+}
+function getDeltaLineStats(prevSha, cwd, headRef = "HEAD") {
+  const result = gitSafeAtRaw(cwd, "diff", `${prevSha}..${headRef}`, "--numstat", "--no-renames");
+  if (!result.ok) return null;
+  const stats = result.stdout.split("\n").filter(Boolean).map((line) => {
+    const [addedRaw, deletedRaw, ...pathParts] = line.split("	");
+    return {
+      path: pathParts.join("	"),
+      added: addedRaw === "-" ? 0 : Number(addedRaw),
+      deleted: deletedRaw === "-" ? 0 : Number(deletedRaw)
+    };
+  });
+  return stats.every((stat) => stat.path.length > 0 && Number.isFinite(stat.added) && Number.isFinite(stat.deleted)) ? stats : null;
+}
 function getTreeDriftFiles(baseRef, cwd) {
   const result = gitSafeAtRaw(cwd, "diff", baseRef, "HEAD", "--name-status", "-M", "-z");
   if (!result.ok) {
@@ -1587,6 +1632,31 @@ function getTreeDriftFiles(baseRef, cwd) {
 }
 
 // src/lib/pipeline-policy.ts
+var CODE_REVIEW_DELTA_LINE_THRESHOLD = 400;
+function isReviewOwnedPath(filePath, facts) {
+  return facts.taskIds.some((id) => filePath === `tasks/${id}` || filePath.startsWith(`tasks/${id}/`)) || facts.telemetryFiles.includes(filePath);
+}
+function resolveCodeReviewScope(facts) {
+  const full = (reason) => ({ scope: "full", base: facts.baseBranch, reason });
+  if (facts.isRound1) return full("Round 1 (initial review)");
+  if (facts.effectiveSize === "XL" || facts.delicate) return full(facts.delicate ? "delicate" : "XL task size");
+  const prev = facts.prevRecord;
+  if (prev === null) return full(facts.previousRecordsDisagree ? "bundle members disagree on the previous reviewed commit" : facts.previousArchiveMalformed ? "unparseable cold-Codex archive record for the previous round" : "no cold-Codex archive record for the previous round");
+  if (!prev.exists) return full(`previous reviewed commit ${prev.reviewedSha} does not resolve`);
+  if (!prev.isAncestor) return full(`previous reviewed commit ${prev.reviewedSha} is not an ancestor of HEAD`);
+  if (prev.equalsHead) return full("previous reviewed commit equals HEAD");
+  if (facts.deltaPaths === null) return full("delta path probe failed");
+  if (facts.priorChangeSetPaths === null) return full("previous change-set path probe failed");
+  if (facts.deltaFileStats === null) return full("delta line-stat probe failed");
+  const priorPaths = new Set(facts.priorChangeSetPaths.filter((p) => !isReviewOwnedPath(p, facts)));
+  const outside = facts.deltaPaths.find((p) => !isReviewOwnedPath(p, facts) && !priorPaths.has(p));
+  if (outside) return full(`${outside} is outside the previous round's change set`);
+  const lines = facts.deltaFileStats.filter((stat) => !isReviewOwnedPath(stat.path, facts)).reduce((sum, stat) => sum + stat.added + stat.deleted, 0);
+  if (lines > CODE_REVIEW_DELTA_LINE_THRESHOLD) {
+    return full(`delta line count ${lines} exceeds ${CODE_REVIEW_DELTA_LINE_THRESHOLD}`);
+  }
+  return { scope: "delta", base: prev.reviewedSha, reason: "delta" };
+}
 var SIZE_ORDER = ["XS", "S", "M", "L", "XL"];
 var SINGLE_PASS_BUDGET_BY_SIZE = {
   XS: "5.00",
@@ -1790,15 +1860,15 @@ function isPlanCombined2(status) {
 import { spawn as spawn2 } from "child_process";
 
 // src/orchestrator/metrics.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 function getMetricsFile(activeCwd) {
   return process.env.CANON_METRICS_FILE_OVERRIDE ? path6.resolve(process.env.CANON_METRICS_FILE_OVERRIDE) : path6.join(activeCwd ?? REPO_ROOT, "docs/pipeline-invocations.md");
 }
 function recordMetric(entry) {
   const metricsFile = getMetricsFile(entry.activeCwd);
-  if (!fs6.existsSync(metricsFile)) {
-    fs6.writeFileSync(metricsFile, [
+  if (!fs7.existsSync(metricsFile)) {
+    fs7.writeFileSync(metricsFile, [
       "# Workflow Metrics",
       "",
       "> Auto-logged by canon's orchestrator. One row per agent invocation.",
@@ -1812,7 +1882,7 @@ function recordMetric(entry) {
   const safeCell = (v) => v.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
   const dur = (entry.durationMs / 1e3).toFixed(1) + "s";
   const tok = entry.tokens != null ? String(entry.tokens) : "-";
-  fs6.appendFileSync(
+  fs7.appendFileSync(
     metricsFile,
     `| ${(/* @__PURE__ */ new Date()).toISOString()} | ${entry.taskId} | ${entry.phase} | ${entry.agent} | ${safeCell(entry.model)} | ${entry.iteration ?? "-"} | ${dur} | ${tok} | ${entry.status} |
 `
@@ -2434,7 +2504,7 @@ function evaluateCodeReviewLoop(tasks, cap) {
 }
 
 // src/orchestrator/validation.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 
 // src/orchestrator/markdown-table.ts
@@ -2751,7 +2821,7 @@ function normalizeCheckLabel(value) {
 }
 function parseValidationRequiredChecks(specPath) {
   try {
-    const content = fs7.readFileSync(specPath, "utf8");
+    const content = fs8.readFileSync(specPath, "utf8");
     const section = content.match(/## Validation Required\n\n([\s\S]*?)(?:\n## |\n# |$)/);
     if (!section) return null;
     const checks = [];
@@ -2838,16 +2908,17 @@ function checkRerouteEvidence(phase, artifactContent, status) {
   }
   return { reroute: true, ok: true };
 }
+var HUMAN_AMENDMENT_HEADING_RE = /^#{2,6}[ \t]+Amendment\b(?![ \t]*\(full-send scope\))/im;
 function verifyRerouteAmendment(taskId, requiredRound) {
   const specPath = path7.join(taskDirFor(taskId), "spec.md");
   let content;
   try {
-    content = fs7.readFileSync(specPath, "utf8");
+    content = fs8.readFileSync(specPath, "utf8");
   } catch {
     return { amended: false, reason: `spec.md missing at ${specPath}` };
   }
   if (requiredRound === 1) {
-    if (/^#{2,6}[ \t]+Amendment\b/im.test(content)) {
+    if (HUMAN_AMENDMENT_HEADING_RE.test(content)) {
       return { amended: true, reason: "" };
     }
     return {
@@ -2872,7 +2943,7 @@ function verifyRerouteAmendment(taskId, requiredRound) {
       reason: `found \`## Amendment Round ${seenRound}\` in ${specPath}, expected \`## Amendment Round ${requiredRound}\``
     };
   }
-  if (/^#{2,6}[ \t]+Amendment\b/im.test(content)) {
+  if (HUMAN_AMENDMENT_HEADING_RE.test(content)) {
     return {
       amended: false,
       reason: `found \`## Amendment\` in ${specPath}, expected \`## Amendment Round ${requiredRound}\``
@@ -3017,7 +3088,7 @@ function classifyPreflightBlockers(taskId, changedFiles, bundleDiffIssues = [])
   const handoffPath = path7.join(taskDirFor(taskId), "handoff.md");
   const specPath = path7.join(taskDirFor(taskId), "spec.md");
   try {
-    const content = fs7.readFileSync(handoffPath, "utf8");
+    const content = fs8.readFileSync(handoffPath, "utf8");
     const latestResults = computeLatestValidationResults(content);
     const requiredChecks = parseValidationRequiredChecks(specPath);
     const { malformed } = parseHandoffChangesRows(taskId);
@@ -3049,7 +3120,7 @@ function validateHandoffAgainstSpec(specPath, handoffPath, latestResults, change
     rowMap = latestResults;
   } else {
     try {
-      const content = fs7.readFileSync(handoffPath, "utf8");
+      const content = fs8.readFileSync(handoffPath, "utf8");
       rowMap = computeLatestValidationResults(content);
     } catch {
       rowMap = /* @__PURE__ */ new Map();
@@ -3103,7 +3174,7 @@ function isTemplateUnfilled(content) {
 function isDoneMdTemplate(donePath) {
   let content;
   try {
-    content = fs7.readFileSync(donePath, "utf8");
+    content = fs8.readFileSync(donePath, "utf8");
   } catch {
     return true;
   }
@@ -3112,7 +3183,7 @@ function isDoneMdTemplate(donePath) {
 function isPrBodyTemplate(prBodyPath) {
   let content;
   try {
-    content = fs7.readFileSync(prBodyPath, "utf8");
+    content = fs8.readFileSync(prBodyPath, "utf8");
   } catch {
     return true;
   }
@@ -3158,7 +3229,7 @@ function checkPhaseGate(taskId, phase, verdict, taskDirOverride) {
     const artifactPath = path7.join(taskDir, config3.artifactName);
     let content;
     try {
-      content = fs7.readFileSync(artifactPath, "utf8");
+      content = fs8.readFileSync(artifactPath, "utf8");
     } catch {
       return { ok: false, reason: `${config3.artifactName} is missing for phase '${phase}'` };
     }
@@ -3170,7 +3241,7 @@ function checkPhaseGate(taskId, phase, verdict, taskDirOverride) {
     if (phase === "spec_review" || phase === "plan") {
       let statusRaw;
       try {
-        statusRaw = fs7.readFileSync(path7.join(taskDir, "status.json"), "utf8");
+        statusRaw = fs8.readFileSync(path7.join(taskDir, "status.json"), "utf8");
       } catch {
         return { ok: false, reason: `cannot determine reroute state for '${phase}': status.json in ${taskDir} is missing or unreadable` };
       }
@@ -3208,7 +3279,7 @@ function checkPhaseGate(taskId, phase, verdict, taskDirOverride) {
     const handoffPath = path7.join(taskDir, "handoff.md");
     let handoffContent;
     try {
-      handoffContent = fs7.readFileSync(handoffPath, "utf8");
+      handoffContent = fs8.readFileSync(handoffPath, "utf8");
     } catch {
       return { ok: false, reason: `closing human_review requires a handoff.md \u2014 none found in ${taskDir}` };
     }
@@ -3217,7 +3288,7 @@ function checkPhaseGate(taskId, phase, verdict, taskDirOverride) {
     const donePath = path7.join(taskDir, "done.md");
     let doneContent = "";
     try {
-      doneContent = fs7.readFileSync(donePath, "utf8");
+      doneContent = fs8.readFileSync(donePath, "utf8");
     } catch {
     }
     if (hasHumanPendingWaiver(doneContent)) return { ok: true };
@@ -3238,7 +3309,7 @@ function parseHandoffChangesRows(taskId) {
   const handoffPath = path7.join(taskDirFor(taskId), "handoff.md");
   let content;
   try {
-    content = fs7.readFileSync(handoffPath, "utf8");
+    content = fs8.readFileSync(handoffPath, "utf8");
   } catch {
     return { files: [], malformed: [] };
   }
@@ -3265,7 +3336,7 @@ function parseAffectedFilesFromSpec(taskId) {
   const specPath = path7.join(taskDirFor(taskId), "spec.md");
   let content;
   try {
-    content = fs7.readFileSync(specPath, "utf8");
+    content = fs8.readFileSync(specPath, "utf8");
   } catch {
     return { files: [], malformed: [] };
   }
@@ -3567,6 +3638,24 @@ function verifyHandoffAgainstDiffFromData(taskIds, inputs) {
   }
   return issues;
 }
+function buildAffectedFilesAllowlist(taskIds, options) {
+  const paths = new Set(PIPELINE_TELEMETRY_FILES);
+  const prefixes = [];
+  for (const taskId of taskIds) {
+    const parsed = parseAffectedFilesFromSpec(taskId);
+    for (const filePath of parsed.files) {
+      if (filePath.endsWith("/")) prefixes.push(filePath);
+      else paths.add(filePath);
+    }
+    for (const malformed of parsed.malformed) {
+      warn(`${taskId} spec.md Affected Files row malformed: ${malformed.reason}`);
+    }
+  }
+  if (options.admitManagedDocs) {
+    for (const doc of PIPELINE_MANAGED_DOCS) paths.add(doc);
+  }
+  return { paths, prefixes };
+}
 function verifyBaseDriftFromData(diffFiles, allowedPaths, taskIds, allowedPrefixes = []) {
   const drift = [];
   for (const filePath of diffFiles) {
@@ -3577,6 +3666,35 @@ function verifyBaseDriftFromData(diffFiles, allowedPaths, taskIds, allowedPrefix
   }
   return drift;
 }
+function classifyBaseDriftFilesFromData(driftFiles, taskChangedFiles) {
+  const baseAdvanced = [];
+  const taskChangedOutOfScope = [];
+  for (const filePath of driftFiles) {
+    if (taskChangedFiles.has(filePath)) taskChangedOutOfScope.push(filePath);
+    else baseAdvanced.push(filePath);
+  }
+  return { baseAdvanced, taskChangedOutOfScope };
+}
+function buildBaseDriftAbortMessage(baseBranch, classification) {
+  const sections = ["--pr aborted: base-drift detected."];
+  if (classification.baseAdvanced.length > 0) sections.push(
+    `The base branch advanced. These files changed only on origin/${baseBranch}:
+` + classification.baseAdvanced.map((file) => `  ${file}`).join("\n") + `
+Merge or rebase the base branch into the task branch, then rerun:
+  git fetch origin ${baseBranch} && git rebase origin/${baseBranch}
+  (or: git merge origin/${baseBranch})`
+  );
+  if (classification.taskChangedOutOfScope.length > 0) sections.push(
+    `These task-changed files are not in the spec's Affected Files:
+` + classification.taskChangedOutOfScope.map((file) => `  ${file}`).join("\n") + `
+The allowlist covers task artifacts, pipeline telemetry (PIPELINE_TELEMETRY_FILES), and spec Affected Files entries, including directory entries.
+Add legitimate paths to the spec's '### Affected Files' table (both sides of a rename), then rerun. If a sibling pipeline or stray task-branch commit introduced a file, remove it with:
+  git checkout origin/${baseBranch} -- <path> && git commit -m 'revert drift on <path>'
+  or: git revert <sha>`
+  );
+  sections.push(`Bypass with --force if you've verified the drift is intentional.`);
+  return sections.join("\n\n");
+}
 function parseDiffNameStatus(stdout) {
   const diffFiles = [];
   const renamePairs = [];
@@ -3608,7 +3726,7 @@ function verifyHandoffAgainstDiff(taskIds, baseRef) {
   for (const taskId of taskIds) {
     let content;
     try {
-      content = fs7.readFileSync(path7.join(taskDirFor(taskId), "handoff.md"), "utf8");
+      content = fs8.readFileSync(path7.join(taskDirFor(taskId), "handoff.md"), "utf8");
     } catch {
       continue;
     }
@@ -3640,31 +3758,18 @@ function verifyBaseDrift(taskIds, baseBranch, cwd) {
   if (!driftResult.ok) {
     return { drift: [], fetchFailed: false, diffFailed: true, diffError: driftResult.stderr };
   }
-  const allowedPaths = new Set(PIPELINE_TELEMETRY_FILES);
-  const allowedPrefixes = [];
+  let admitManagedDocs = false;
   for (const taskId of taskIds) {
-    const parsed = parseAffectedFilesFromSpec(taskId);
-    for (const filePath of parsed.files) {
-      if (filePath.endsWith("/")) {
-        allowedPrefixes.push(filePath);
-      } else {
-        allowedPaths.add(filePath);
-      }
-    }
-    for (const malformed of parsed.malformed) {
-      warn(`${taskId} spec.md Affected Files row malformed: ${malformed.reason}`);
-    }
     try {
       if (readStatus(taskId).phases.qa?.status === "done") {
-        for (const doc of PIPELINE_MANAGED_DOCS) {
-          allowedPaths.add(doc);
-        }
+        admitManagedDocs = true;
       }
     } catch {
     }
   }
+  const allowlist = buildAffectedFilesAllowlist(taskIds, { admitManagedDocs });
   return {
-    drift: verifyBaseDriftFromData(driftResult.files, allowedPaths, taskIds, allowedPrefixes),
+    drift: verifyBaseDriftFromData(driftResult.files, allowlist.paths, taskIds, allowlist.prefixes),
     fetchFailed: false,
     diffFailed: false
   };
@@ -3682,7 +3787,7 @@ function verifyBaseDivergenceFromData(commits) {
 function verifyBaseDivergence(baseBranch, cwd) {
   const fetchResult = gitSafeAt(cwd, "fetch", "origin", baseBranch);
   if (!fetchResult.ok) {
-    if (!fs7.existsSync(cwd)) {
+    if (!fs8.existsSync(cwd)) {
       return { commits: [], ok: false, stderr: fetchResult.stderr, fetchFailed: false };
     }
     warn(
@@ -3766,11 +3871,11 @@ function buildSharedDocAbortMessage(abortedFiles) {
 }
 
 // src/orchestrator/prompts/index.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path11 from "path";
 
 // src/orchestrator/context.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path8 from "path";
 function extractAffectedFiles(taskId) {
   try {
@@ -3784,7 +3889,7 @@ function isSafeRepoPath(file) {
   const resolved = path8.resolve(REPO_ROOT, file);
   if (!resolved.startsWith(REPO_ROOT + path8.sep)) return false;
   try {
-    const real = fs8.realpathSync(resolved);
+    const real = fs9.realpathSync(resolved);
     if (!real.startsWith(REPO_ROOT + path8.sep)) return false;
   } catch {
   }
@@ -3798,7 +3903,7 @@ function buildContextBlock(taskIds) {
       if (!isSafeRepoPath(file)) continue;
       const filePath = path8.join(REPO_ROOT, file);
       try {
-        allFiles.set(file, fs8.readFileSync(filePath, "utf8"));
+        allFiles.set(file, fs9.readFileSync(filePath, "utf8"));
       } catch {
       }
     }
@@ -3829,7 +3934,7 @@ ${content}
 function buildKnownPitfalls(taskIds) {
   const patternsPath = process.env.CANON_PATTERNS_MD_PATH ?? path8.join(getActiveCwd(taskIds), "docs/patterns.md");
   try {
-    const content = fs8.readFileSync(patternsPath, "utf8");
+    const content = fs9.readFileSync(patternsPath, "utf8");
     const match = content.match(/## Known Pitfalls\n\n([\s\S]*?)(?:\n## |\n---|\n# |$)/);
     if (!match) return "";
     return `
@@ -3846,7 +3951,7 @@ function buildKnownRisks(taskIds) {
   const riskBlocks = taskIds.map((taskId) => {
     const specPath = path8.join(taskDirFor(taskId), "spec.md");
     try {
-      const content = fs8.readFileSync(specPath, "utf8");
+      const content = fs9.readFileSync(specPath, "utf8");
       const match = content.match(/## Known Risks\n\n([\s\S]*?)(?:\n## |\n# |$)/);
       if (!match) return "";
       const risks = match[1].trim();
@@ -3873,7 +3978,7 @@ function summarizePreloadStatus(taskIds) {
       if (!isSafeRepoPath(file)) continue;
       const filePath = path8.join(REPO_ROOT, file);
       try {
-        files.set(file, fs8.statSync(filePath).size);
+        files.set(file, fs9.statSync(filePath).size);
       } catch {
         files.set(file, 0);
       }
@@ -3890,7 +3995,7 @@ function summarizePreloadStatus(taskIds) {
 function extractValidationChecks(taskId) {
   const specPath = path8.join(taskDirFor(taskId), "spec.md");
   try {
-    const content = fs8.readFileSync(specPath, "utf8");
+    const content = fs9.readFileSync(specPath, "utf8");
     const section = content.match(/## Validation Required\n\n([\s\S]*?)(?:\n## |\n# |$)/);
     if (!section) return [];
     const checks = [];
@@ -3906,7 +4011,7 @@ function extractValidationChecks(taskId) {
 function extractAcSummary(taskId) {
   const specPath = path8.join(taskDirFor(taskId), "spec.md");
   try {
-    const content = fs8.readFileSync(specPath, "utf8");
+    const content = fs9.readFileSync(specPath, "utf8");
     const lines = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^-\s+\[[ x]\]\s+(AC-[\w.-]+):\s+(.+)$/);
@@ -3996,11 +4101,11 @@ ${acSection}`;
 }
 
 // src/orchestrator/review-archive.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path10 from "path";
 
 // src/task/templates.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path9 from "path";
 function tasksRoot() {
   return process.env.CANON_TASKS_DIR_OVERRIDE ?? "tasks";
@@ -4013,17 +4118,17 @@ function taskTemplateOverrideRoot() {
 }
 function resolveTaskTemplateSource(basename) {
   const override = path9.join(taskTemplateOverrideRoot(), basename);
-  if (fs9.existsSync(override)) return override;
+  if (fs10.existsSync(override)) return override;
   const managed = path9.join(templatesRoot(), basename);
-  return fs9.existsSync(managed) ? managed : null;
+  return fs10.existsSync(managed) ? managed : null;
 }
 function renderTaskTemplate(source, taskId, title) {
-  return fs9.readFileSync(source, "utf8").replaceAll("[TASK-ID]", taskId).replaceAll("[Title]", title);
+  return fs10.readFileSync(source, "utf8").replaceAll("[TASK-ID]", taskId).replaceAll("[Title]", title);
 }
 function scaffoldTaskArtifact(taskDir, basename, taskId, title) {
   const source = resolveTaskTemplateSource(basename);
   if (!source) return null;
-  fs9.writeFileSync(path9.join(taskDir, basename), renderTaskTemplate(source, taskId, title), "utf8");
+  fs10.writeFileSync(path9.join(taskDir, basename), renderTaskTemplate(source, taskId, title), "utf8");
   return source;
 }
 function isPristineTaskArtifact(content, basename, taskId, title) {
@@ -4039,10 +4144,79 @@ function isPristineTaskArtifact(content, basename, taskId, title) {
 
 // src/orchestrator/review-archive.ts
 var REVIEW_ARCHIVE_PREFIX = "review-prior-";
+var COLD_CODEX_ARCHIVE_PREFIX = "review-cold-codex-run-";
+var COLD_CODEX_ARCHIVE_RE = /^review-cold-codex-run-(\d+)\.md$/;
+function writeColdCodexArchive(taskDir, header, findings) {
+  let newest = 0;
+  for (const name2 of fs11.readdirSync(taskDir)) {
+    const match = COLD_CODEX_ARCHIVE_RE.exec(name2);
+    if (match) newest = Math.max(newest, Number(match[1]));
+  }
+  const name = `${COLD_CODEX_ARCHIVE_PREFIX}${newest + 1}.md`;
+  const reason = header.reason.replaceAll('"', "'");
+  fs11.writeFileSync(
+    path10.join(taskDir, name),
+    `<!-- round=${header.round} reviewed_sha=${header.reviewedSha} scope=${header.scope} base=${header.base} reason="${reason}" -->
+
+${findings}`,
+    "utf8"
+  );
+  return name;
+}
+function parseColdCodexArchiveHeader(content) {
+  const match = /^<!-- round=(\d+) reviewed_sha=([a-f\d]{40,64}) scope=(full|delta) base=(\S+) reason="([^"\n]*)" -->\r?\n\r?\n/.exec(content);
+  if (!match) return null;
+  return {
+    round: Number(match[1]),
+    reviewedSha: match[2],
+    scope: match[3],
+    base: match[4],
+    reason: match[5]
+  };
+}
+function findColdCodexArchiveForRound(taskDir, round) {
+  let names;
+  try {
+    names = fs11.readdirSync(taskDir);
+  } catch {
+    return null;
+  }
+  const numbered = names.flatMap((name) => {
+    const match = COLD_CODEX_ARCHIVE_RE.exec(name);
+    return match ? [{ name, number: Number(match[1]) }] : [];
+  }).sort((a, b) => b.number - a.number);
+  for (const { name } of numbered) {
+    let content;
+    try {
+      content = fs11.readFileSync(path10.join(taskDir, name), "utf8");
+    } catch {
+      continue;
+    }
+    const header = parseColdCodexArchiveHeader(content);
+    if (header?.round === round) return header;
+  }
+  return null;
+}
+function hasMalformedColdCodexArchive(taskDir) {
+  let names;
+  try {
+    names = fs11.readdirSync(taskDir);
+  } catch {
+    return false;
+  }
+  return names.some((name) => {
+    if (!COLD_CODEX_ARCHIVE_RE.test(name)) return false;
+    try {
+      return parseColdCodexArchiveHeader(fs11.readFileSync(path10.join(taskDir, name), "utf8")) === null;
+    } catch {
+      return true;
+    }
+  });
+}
 var REVIEW_ARCHIVE_RE = new RegExp(`^${REVIEW_ARCHIVE_PREFIX}(\\d+)\\.md$`);
 function newestReviewArchiveNumber(taskDir) {
   let newest = 0;
-  for (const name of fs10.readdirSync(taskDir)) {
+  for (const name of fs11.readdirSync(taskDir)) {
     const match = REVIEW_ARCHIVE_RE.exec(name);
     if (match) newest = Math.max(newest, Number(match[1]));
   }
@@ -4054,21 +4228,21 @@ function findNewestReviewArchive(taskDir) {
 }
 function archivePriorReview(taskDir, options = {}) {
   const reviewPath = path10.join(taskDir, "review.md");
-  if (!fs10.existsSync(reviewPath)) return null;
+  if (!fs11.existsSync(reviewPath)) return null;
   if (options.skipUnfilledTemplate) {
-    const content = fs10.readFileSync(reviewPath, "utf8");
+    const content = fs11.readFileSync(reviewPath, "utf8");
     if (isTemplateUnfilled(content)) return null;
     if (options.scaffold && isPristineTaskArtifact(content, "review.md", options.scaffold.taskId, options.scaffold.title)) {
       return null;
     }
   }
   const archiveName = `${REVIEW_ARCHIVE_PREFIX}${newestReviewArchiveNumber(taskDir) + 1}.md`;
-  fs10.renameSync(reviewPath, path10.join(taskDir, archiveName));
+  fs11.renameSync(reviewPath, path10.join(taskDir, archiveName));
   return archiveName;
 }
 function rescaffoldReview(taskDir, identity) {
   try {
-    if (fs10.existsSync(path10.join(taskDir, "review.md"))) return { outcome: "exists" };
+    if (fs11.existsSync(path10.join(taskDir, "review.md"))) return { outcome: "exists" };
     const source = scaffoldTaskArtifact(taskDir, "review.md", identity.taskId, identity.title);
     return source ? { outcome: "written", source } : { outcome: "no-template" };
   } catch (error) {
@@ -4542,10 +4716,10 @@ function renderTemplate(template, view) {
 }
 
 // src/orchestrator/prompts/templates/code-review-foreman.md
-var code_review_foreman_default = "You are the synthesis foreman for the code review phase for {{taskScope}} for {{projectName}}.\n\n{{{startup}}}\n\n## Code-Review Rules of Thumb (Foreman)\n\n- **Reviewer diffs against the task baseline, not `main`, on release branches**: on a shared release branch ahead of `main`, always diff against the task's baseline \u2014 diffing against `main` attributes unrelated work to the task.\n- **Use `git -C <absolute-path>` for every worktree git op, not `cd` + git**: when operating across REPO_ROOT and a task worktree, `git -C /absolute/path` avoids silent cwd reversion between tool calls.\n- **Don't infer one git invariant from another**: `git status --porcelain` empty \u2260 origin matches HEAD; `origin/<branch>` exists \u2260 origin matches HEAD; PR exists \u2260 PR is in the expected state. Do the actual check directly.\n- **A cross-cutting invariant belongs in one shared helper, not patched per call site**: when the same rule must hold at multiple enforcement points, implement it once. The tell: findings come back round after round as the same bug class at a new location. At \u22653 sites, extract the shared helper and route all sites through it.\n\nYour job is to synthesize three review inputs: the anchored Claude lens, the cold-Claude lens, and the pre-obtained cold-Codex findings injected below. You spawn the Claude lenses as isolated sub-agents, collect their findings, adjudicate all three inputs using the spec (which you hold and the cold lenses do not), then write one `review.md` and set the verdict. Do not run `codex` yourself.\n\nTasks:\n{{{taskLines}}}\n\n{{#isRound1}}\nThis is Round 1, the initial code review.\n{{/isRound1}}\n{{^isRound1}}\nThis is Round {{roundN}}: re-review after iteration {{priorIteration}}. The lenses re-run from scratch. Direct the anchored lens to read the Iteration {{priorIteration}} section of `handoff.md` that addresses review round {{priorIteration}}.\n{{#tightenLine}}\n{{{tightenLine}}}\n{{/tightenLine}}\n{{/isRound1}}\n\n{{#hasDiff}}\nTask diff against {{{baseBranch}}}:\n\n```diff\n{{{diffContent}}}\n```\n{{#diffTruncated}}\n> Diff truncated at 50 000 bytes. Give the Claude lenses the visible diff first; for the omitted remainder, direct them to inspect only the changed files named in the handoff Changes table. Do not give the cold-Claude lens spec, AC, or canon-doc context.\n{{/diffTruncated}}\n{{/hasDiff}}\n{{^hasDiff}}\nRetrieve the task diff with `git diff {{{baseBranch}}}...HEAD`.\n{{/hasDiff}}\n\n## Injected Cold-Codex Findings\n\n{{#hasColdCodexFindings}}\nThe orchestrator ran `codex review` over the task's branch diff before spawning you. Its findings are reproduced below. These are unanchored: Codex reviewed adversarially without the spec as a checklist. Treat them as the third lens input. Do not re-run Codex; synthesize these findings alongside the Claude lens outputs.\n\n{{{coldCodexFindings}}}\n{{/hasColdCodexFindings}}\n{{^hasColdCodexFindings}}\nNo cold-Codex findings were provided to this prompt. In production code_review, the orchestrator must obtain that artifact before foreman synthesis; do not treat a missing cold-Codex lens as approval evidence.\n{{/hasColdCodexFindings}}\n\n## Foreman Protocol\n\n### 1. Spawn Claude Lenses In Parallel\n\nSpawn both Claude lenses with the sub-agent tool (`Agent`, called `Task` in older harnesses) in a single message so they run concurrently, and run them **in the foreground** (`run_in_background: false`) so the call returns their findings. Do not spawn them in the background and do not end your turn to wait for them: a turn that ends while a lens is still running ends the code review with no `review.md` and no verdict, and the phase is retried from scratch. Your turn ends only after step 5 below has run.\n\n**Anchored lens** (`subagent_type: code-review-anchored`)\n- Give it the full diff, `spec.md`, `handoff.md`, and prior `review.md` if this is a re-review.\n- It applies canon's anchored Stage 1 / Stage 2 code-review charter.\n- It returns structured findings to you. It must not write `review.md` or run `canon task phase`.\n\n**Cold-Claude lens** (`subagent_type: code-review-cold`)\n- Give it the full diff and base ref only.\n- Do not give it `spec.md`, ACs, handoff rationale, canon docs, known risks, or your anchored-lens prompt.\n- If it needs to inspect files for truncated diff context, constrain it to changed files only and preserve the spec-blind framing.\n- It returns structured findings to you. It must not write `review.md` or run `canon task phase`.\n\nThe injected cold-Codex findings above are the third lens input. Do not spawn a Codex agent or shell out to Codex yourself. Do not let a Claude lens see another lens's output.\n\n### 2. Adjudicate\n\nUse the three lens inputs and the spec. Do not perform a new full diff review for novel bugs; your role is synthesis and adjudication.\n\nThe lenses are instructed to over-report \u2014 to surface low-confidence and low-severity findings rather than self-censor. Filtering is **your** job, not theirs: a quiet lens output is a bug in the lens, not a clean diff. Rank surviving findings by confidence \xD7 severity. A low-confidence, low-severity finding is a nit or gets dismissed; it does not by itself drive `changes_requested`. Do not discard a finding merely because a lens marked it low-confidence \u2014 verify it against the spec/diff first, then rank.\n\n1. Dedup: if 2+ lenses flagged the same behavior, collapse it to one finding and record \"flagged by N lenses.\" A finding flagged by 2+ lenses is higher-confidence regardless of any lens's self-tag. Cross-model agreement \u2014 the same behavior flagged by cold-Claude and cold-Codex \u2014 must not be dismissed as spec-intended without explicit spec evidence cited in `review.md`.\n2. Keep the two reconciliation checks separate:\n   - Does it hold against the code? For cold findings (cold-Claude and cold-Codex), verify each against the diff/code. Codex P-levels are claims to check, not verdicts. A finding that does not hold gets recorded as `Dismissed (cold-Claude): <finding> - <reason>` or `Dismissed (cold-Codex): <finding> - <reason>`.\n   - Is it in spec scope? Apply this only to anchored-lens findings as part of the Stage 1 / Stage 2 charter.\n   - Forbidden: do not dismiss a verified cold-Claude or cold-Codex finding merely for being off-AC or out of spec scope. A real bug caught by a cold lens is still a bug even if no AC named it.\n3. Altitude classification: every surviving finding is either:\n   - `code-bug`: the implementation is wrong or test integrity is compromised.\n   - `spec-gap`: the implementation may match the written spec, but the spec is missing, wrong, or too ambiguous for the implementer to fix.\n\n### 3. Choose Verdict\n\n- Any `code-bug` finding -> `changes_requested`.\n- Any `spec-gap` finding and no code-bugs -> `spec_gap`.\n- Optional nits or cleanup without blocking findings -> `approved_with_nits`.\n- No surviving findings -> `approved`.\n\nTest-integrity findings are always code-bugs.\n\n### 4. Write `review.md`\n\nFor each task, write `tasks/<id>/review.md`.\n\nRound 1 fills the existing template structure directly \u2014 do **not** wrap it in a `## Round 1` section; the `## Stage 1` and `## Stage 2` headings stay at H2. Re-review appends a new `## Round {{roundN}}` section near the bottom (with `### Stage 1` / `### Stage 2` sub-headings), preserving earlier rounds.\n\nInclude:\n- Stage 1: anchored lens validation gate result and AC table.\n- Stage 2 / Findings: surviving findings with altitude (`code-bug` or `spec-gap`), source lens, and file:line.\n- Dismissed Cold Findings: every dropped cold finding plus the reason, including `Dismissed (cold-Claude): ...` and `Dismissed (cold-Codex): ...` entries where applicable.\n- Final Verdict: check exactly one verdict checkbox, including `Spec gap` when applicable.\n\n### 5. Set Phase Verdict\n\nRun one command per task with the actual verdict:\n{{{phaseCommands}}}\n";
+var code_review_foreman_default = "You are the synthesis foreman for the code review phase for {{taskScope}} for {{projectName}}.\n\n{{{startup}}}\n\n## Code-Review Rules of Thumb (Foreman)\n\n- **Reviewer diffs against the task baseline, not `main`, on release branches**: on a shared release branch ahead of `main`, always diff against the task's baseline \u2014 diffing against `main` attributes unrelated work to the task.\n- **Use `git -C <absolute-path>` for every worktree git op, not `cd` + git**: when operating across REPO_ROOT and a task worktree, `git -C /absolute/path` avoids silent cwd reversion between tool calls.\n- **Don't infer one git invariant from another**: `git status --porcelain` empty \u2260 origin matches HEAD; `origin/<branch>` exists \u2260 origin matches HEAD; PR exists \u2260 PR is in the expected state. Do the actual check directly.\n- **A cross-cutting invariant belongs in one shared helper, not patched per call site**: when the same rule must hold at multiple enforcement points, implement it once. The tell: findings come back round after round as the same bug class at a new location. At \u22653 sites, extract the shared helper and route all sites through it.\n\nYour job is to synthesize three review inputs: the anchored Claude lens, the cold-Claude lens, and the pre-obtained cold-Codex findings injected below. You spawn the Claude lenses as isolated sub-agents, collect their findings, adjudicate all three inputs using the spec (which you hold and the cold lenses do not), then write one `review.md` and set the verdict. Do not run `codex` yourself.\n\nTasks:\n{{{taskLines}}}\n\n{{#isRound1}}\nThis is Round 1, the initial code review.\n{{/isRound1}}\n{{^isRound1}}\nThis is Round {{roundN}}: re-review after iteration {{priorIteration}}. All three lenses run again this round. Direct the anchored lens to read the Iteration {{priorIteration}} section of `handoff.md` that addresses review round {{priorIteration}}.\n{{#tightenLine}}\n{{{tightenLine}}}\n{{/tightenLine}}\n{{/isRound1}}\n\n**Scope:** {{{scopeWord}}} \u2014 base `{{{scopeBase}}}` \u2014 reason: {{{scopeReason}}}\n\n{{#hasDiff}}\nTask diff against {{{baseBranch}}}:\n\n```diff\n{{{diffContent}}}\n```\n{{#diffTruncated}}\n> Diff truncated at 50 000 bytes. Give the Claude lenses the visible diff first; for the omitted remainder, direct them to inspect only the changed files named in the handoff Changes table. Do not give the cold-Claude lens spec, AC, or canon-doc context.\n{{/diffTruncated}}\n{{/hasDiff}}\n{{^hasDiff}}\nRetrieve the task diff with `git diff {{{baseBranch}}}...HEAD`.\n{{/hasDiff}}\n{{#isDeltaScope}}\n\n{{#hasDeltaDiff}}\nDelta diff (`{{{deltaBase}}}..HEAD`) \u2014 give this delta to the cold-Claude lens:\n\n```diff\n{{{deltaDiffContent}}}\n```\n{{#deltaDiffTruncated}}\n> Delta diff truncated at 50 000 bytes. Give the cold-Claude lens the visible delta first; for the remainder, direct it to `git diff {{{deltaBase}}}..HEAD`.\n{{/deltaDiffTruncated}}\n{{/hasDeltaDiff}}\n{{^hasDeltaDiff}}\nThe delta diff could not be injected. Retrieve it with `git diff {{{deltaBase}}}..HEAD` and give it to the cold-Claude lens before it reviews.\n{{/hasDeltaDiff}}\n{{/isDeltaScope}}\n\n## Injected Cold-Codex Findings\n\n{{#hasColdCodexFindings}}\nThe orchestrator ran `codex review` before spawning you. Its findings are reproduced below. These are unanchored: Codex reviewed adversarially without the spec as a checklist. Treat them as the third lens input. Do not re-run Codex; synthesize these findings alongside the Claude lens outputs.\n{{#isDeltaScope}}\nFor this round, cold-Codex reviewed only `{{{deltaBase}}}..HEAD`.\n{{/isDeltaScope}}\n{{^isDeltaScope}}\nFor this round, cold-Codex reviewed the full task diff against `{{{baseBranch}}}`.\n{{/isDeltaScope}}\n\n{{{coldCodexFindings}}}\n{{/hasColdCodexFindings}}\n{{^hasColdCodexFindings}}\nNo cold-Codex findings were provided to this prompt. In production code_review, the orchestrator must obtain that artifact before foreman synthesis; do not treat a missing cold-Codex lens as approval evidence.\n{{/hasColdCodexFindings}}\n\n{{#hasOutOfScopeFiles}}\n## Full-Send Scope Judgment\n\nThe task changed these files outside the spec's `### Affected Files` table:\n\n{{{outOfScopeFilesList}}}\n\nJudge each file against the owning task's ACs and record its outcome and reason in `review.md`:\n\n1. **Appropriate scope expansion:** If needed to meet the ACs and consistent with the spec's intent, append an `## Amendment (full-send scope)` section to the owning task's `spec.md` (use exactly that heading; a bare `## Amendment` is reserved for human reroute amendments). Include an exact `### Affected Files` heading and table row naming the file, plus a one-line reason that calls it a full-send scope expansion.\n2. **Spec miss:** If the spec should have listed the file, append the same `## Amendment (full-send scope)` section and exact `### Affected Files` table row, with a one-line reason that calls it a spec miss.\n3. **Should not have been changed:** Do not amend the spec. Write a finding requiring the file to be reverted or removed, and set the verdict to `changes_requested`.\n\nFor a bundle, amend the member spec whose ACs the file serves. The orchestrator checks after code review completes: every listed file must be in a member's Affected Files or a `changes_requested` verdict must route it back to implement. The legacy `needs_re_review` verdict routes the same way. A `spec_gap` verdict blocks for human triage and names any files still outside Affected Files; blessing that verdict does not amend the spec. An approved review with unjudged files auto-blocks.\n\n{{/hasOutOfScopeFiles}}\n## Foreman Protocol\n\n### 1. Spawn Claude Lenses In Parallel\n\nSpawn both Claude lenses with the sub-agent tool (`Agent`, called `Task` in older harnesses) in a single message so they run concurrently, and run them **in the foreground** (`run_in_background: false`) so the call returns their findings. Do not spawn them in the background and do not end your turn to wait for them: a turn that ends while a lens is still running ends the code review with no `review.md` and no verdict, and the phase is retried from scratch. Your turn ends only after step 5 below has run.\n\n**Anchored lens** (`subagent_type: code-review-anchored`)\n{{#isDeltaScope}}\n- Retrieve the full task diff with `git diff {{{baseBranch}}}...HEAD` and give it that full diff, not the delta, plus `spec.md`, `handoff.md`, and prior `review.md`.\n{{/isDeltaScope}}\n{{^isDeltaScope}}\n- Give it the full diff, `spec.md`, `handoff.md`, and prior `review.md` if this is a re-review.\n{{/isDeltaScope}}\n- It applies canon's anchored Stage 1 / Stage 2 code-review charter.\n- It returns structured findings to you. It must not write `review.md` or run `canon task phase`.\n\n**Cold-Claude lens** (`subagent_type: code-review-cold`)\n{{#isDeltaScope}}\n- This round is delta-scoped. Give it the delta (`{{{deltaBase}}}..HEAD`) and the delta base ref only.\n{{/isDeltaScope}}\n{{^isDeltaScope}}\n- Give it the full diff and base ref only.\n{{/isDeltaScope}}\n- Do not give it `spec.md`, ACs, handoff rationale, canon docs, known risks, or your anchored-lens prompt.\n- If it needs to inspect files for truncated diff context, constrain it to changed files only and preserve the spec-blind framing.\n- Separately, its sibling-site sweep may search other code files for guards, checks, and invariants that need the same treatment. Keep the search spec-blind.\n- It returns structured findings to you. It must not write `review.md` or run `canon task phase`.\n\nThe injected cold-Codex findings above are the third lens input. Do not spawn a Codex agent or shell out to Codex yourself. Do not let a Claude lens see another lens's output.\n\n### 2. Adjudicate\n\nUse the three lens inputs and the spec. Do not perform a new full diff review for novel bugs; your role is synthesis and adjudication.\n\nThe lenses are instructed to over-report \u2014 to surface low-confidence and low-severity findings rather than self-censor. Filtering is **your** job, not theirs: a quiet lens output is a bug in the lens, not a clean diff. Rank surviving findings by confidence \xD7 severity. A low-confidence, low-severity finding is a nit or gets dismissed; it does not by itself drive `changes_requested`. Do not discard a finding merely because a lens marked it low-confidence \u2014 verify it against the spec/diff first, then rank.\n\n1. Dedup: if 2+ lenses flagged the same behavior, collapse it to one finding and record \"flagged by N lenses.\" A finding flagged by 2+ lenses is higher-confidence regardless of any lens's self-tag. Cross-model agreement \u2014 the same behavior flagged by cold-Claude and cold-Codex \u2014 must not be dismissed as spec-intended without explicit spec evidence cited in `review.md`.\n2. Keep the two reconciliation checks separate:\n   - Does it hold against the code? For cold findings (cold-Claude and cold-Codex), verify each against the diff/code. Codex P-levels are claims to check, not verdicts. A finding that does not hold gets recorded as `Dismissed (cold-Claude): <finding> - <reason>` or `Dismissed (cold-Codex): <finding> - <reason>`.\n   - Is it in spec scope? Apply this only to anchored-lens findings as part of the Stage 1 / Stage 2 charter.\n   - Forbidden: do not dismiss a verified cold-Claude or cold-Codex finding merely for being off-AC or out of spec scope. A real bug caught by a cold lens is still a bug even if no AC named it.\n3. Altitude classification: every surviving finding is either:\n   - `code-bug`: the implementation is wrong or test integrity is compromised.\n   - `spec-gap`: the implementation may match the written spec, but the spec is missing, wrong, or too ambiguous for the implementer to fix.\n\n### 3. Choose Verdict\n\n- Any `code-bug` finding -> `changes_requested`.\n- Any `spec-gap` finding and no code-bugs -> `spec_gap`.\n- Optional nits or cleanup without blocking findings -> `approved_with_nits`.\n- No surviving findings -> `approved`.\n\nTest-integrity findings are always code-bugs.\n\n### 4. Write `review.md`\n\nFor each task, write `tasks/<id>/review.md`.\n\nRound 1 fills the existing template structure directly \u2014 do **not** wrap it in a `## Round 1` section; the `## Stage 1` and `## Stage 2` headings stay at H2. Re-review appends a new `## Round {{roundN}}` section near the bottom (with `### Stage 1` / `### Stage 2` sub-headings), preserving earlier rounds.\n\nEvery round \u2014 the Round 1 body and each `## Round N` section \u2014 includes one scope line near the top: **Scope:** {{{scopeWord}}} \u2014 base `{{{scopeBase}}}` \u2014 reason: {{{scopeReason}}}. The numbered cold-Codex archive header is the machine-readable record.\n\nInclude:\n- Stage 1: anchored lens validation gate result and AC table.\n- Stage 2 / Findings: surviving findings with altitude (`code-bug` or `spec-gap`), source lens, and file:line.\n- Dismissed Cold Findings: every dropped cold finding plus the reason, including `Dismissed (cold-Claude): ...` and `Dismissed (cold-Codex): ...` entries where applicable.\n- Final Verdict: check exactly one verdict checkbox, including `Spec gap` when applicable.\n\n### 5. Set Phase Verdict\n\nRun one command per task with the actual verdict:\n{{{phaseCommands}}}\n";
 
 // src/orchestrator/prompts/templates/implement.md
-var implement_default = 'You are implementing {{taskScope}} for {{projectName}}.\n\n{{{stateHeader}}}\n{{{startup}}}\n{{{risksBlock}}}{{{pitfallsBlock}}}{{{contextBlock}}}\n{{{affectedFilesBlock}}}\nTasks to implement:\n{{{taskLines}}}{{#isBundle}}\nThese tasks are related \u2014 implement them together. Consider shared code paths and cross-task interactions.{{/isBundle}}\n\nGrounding rule: before you write handoff.md, re-open the files you changed and verify the current diff against the spec. Do not treat a previous session\'s memory as proof that the work is already in place.\n\n**Spec ACs are binding. Plan approach is guidance.**\n- Every Acceptance Criterion in spec.md MUST be met \u2014 these are non-negotiable.\n- If you find a better implementation approach than what\'s in the plan, use it. Document every deviation in handoff.md under "Deviations" with specific rationale.\n- You may NOT silently drop an AC, skip a required validation check, or omit a spec requirement.\n- If an AC is infeasible as written, document it in Blockers \u2014 do not silently skip.\n- If an AC is ambiguous enough that two reasonable implementations exist, document your interpretation in handoff.md under Blockers with label `[ambiguity]` \u2014 do not silently guess. Claude will evaluate whether the interpretation was correct.\n\n## Implementation Rules\n\n**Safe-First Rules** \u2014 always applicable regardless of stack:\n1. For storage, reload, sync, or data-affecting flows: ship the safer guarded behavior first.\n2. Behavior that reloads the app, replaces local state, or dismisses user work must be gated by explicit user action.\n3. Prefer shared types over duplicating signatures.\n\n**Scope Discipline** \u2014 always applicable; the spec is the contract:\n1. **Affected Files is the scope cap.** If satisfying an AC genuinely requires editing files outside the spec\'s *Affected Files* table, do not make that edit. Record the gap in `handoff.md` under *Blockers* \u2014 the handoff is how it reaches a human \u2014 then finish the remaining in-scope work, the handoff, and the phase command. Do not silently expand scope.\n2. **No unauthorized new abstractions.** Do not introduce new top-level modules, services, packages, or routing layers that the spec did not authorize. Minor refactors within an authorized file are fine; new abstractions are an architecture decision and belong in the spec.\n3. **No incidental dependency changes.** Do not add, remove, upgrade, or downgrade dependencies (or their pinned versions) unless the spec explicitly requests it.\n\n**Lint & Type Safety Policy** \u2014 always applicable:\n1. **Suppressing a lint or type error is a last resort**, not a convenience escape hatch. Never add a suppression without a same-line justification explaining *why the rule is wrong for this specific case*.\n2. **`any` / dynamic typing**: When the shape is truly unknown at the boundary, type as `unknown` and narrow explicitly.\n\n**Bug/Flake-Fix Red-First Checkpoint** \u2014 applicable when a spec\'s ACs include a red-first regression test:\nWrite the test and run it against the pre-fix code first; confirm it fails *for the reason the spec states*, then apply the fix and confirm it passes. Report the red run (command + observed failure) in handoff.md. If the test cannot be made to fail on the pre-fix code for the stated reason, do not implement a fix on a premise you could not reproduce \u2014 record a `[wrong-premise]` Blocker in handoff.md instead, then finish the remaining in-scope work, the handoff, and the phase command. If the spec instead uses the environment-bound-and-impractical escape, run its named deterministic alternative before fixing if it is executable in your sandbox (e.g. an integration fixture) and report the outcome in handoff.md the same way; if it is not executable (e.g. a documented manual repro), state that in handoff.md instead \u2014 never report an outcome for a run that did not happen.\n\n**Parsing Structured Input** \u2014 always applicable when implementing a parser for author-facing structured input:\nParse cell-by-cell with explicit rejection, not a permissive whole-string regex. Anchor each cell to exactly one expected shape and reject malformed cells with a specific reason at the parse boundary.\n\nRun ALL applicable validation checks before writing handoff. See "Validation Required" in each spec.md. The universal change-type \u2192 check-category matrix:\n\n| Change Type | Required Check Categories |\n|---|---|\n| Most changes | Linting, type checking, unit tests |\n| Docs references | Docs references |\n| Routes / config / build | Full build |\n| UI / interaction changes | End-to-end tests |\n| Content / SEO / metadata | Prerender / sitemap / feed regeneration |\n| Schema / migration | Migration runner + manual review |\n| Cross-platform | Subset of the above on each platform |\n\nFor which command runs each category: see `docs/architecture.md` \xA7Validation (project command bindings). Required checks must be recorded as Pass or Fail; do not mark a required check N/A unless the spec explicitly removed it.\n\n**Test flakiness in your sandbox.** Validation suites \u2014 especially E2E or integration tests \u2014 can hit transient failures (timing races, environment quirks, network jitter) that have nothing to do with the code in your spec\'s Affected Files. **If a failure is in a test / file outside your Affected Files table, do NOT fix it.** Note the observed test name, file, line, and a one-line repro hint in handoff.md \u2192 Blockers (or "Validation Outcomes" Notes column with status `Fail \u2013 unrelated`), then continue. `Fail \u2013 unrelated` is only valid for failures in files outside your Affected Files; a failure in a file you changed is yours to fix. Scope discipline > fixing adjacent bugs you spot during validation. The reviewer/operator will decide whether to triage the unrelated failure separately.\n\nFor each task, write tasks/<id>/handoff.md using the template. The Validation Outcomes table must have no Fail results EXCEPT for unrelated-flake rows clearly labeled in the Notes column.\nAppend to tasks/<id>/notes.md for any surprising codebase behavior (prefix: [implement]).\n\nWhen done, run:\n{{{phaseCommands}}}\n';
+var implement_default = 'You are implementing {{taskScope}} for {{projectName}}.\n\n{{{stateHeader}}}\n{{{startup}}}\n{{{risksBlock}}}{{{pitfallsBlock}}}{{{contextBlock}}}\n{{{affectedFilesBlock}}}\nTasks to implement:\n{{{taskLines}}}{{#isBundle}}\nThese tasks are related \u2014 implement them together. Consider shared code paths and cross-task interactions.{{/isBundle}}\n\nGrounding rule: before you write handoff.md, re-open the files you changed and verify the current diff against the spec. Do not treat a previous session\'s memory as proof that the work is already in place.\n\n**Spec ACs are binding. Plan approach is guidance.**\n- Every Acceptance Criterion in spec.md MUST be met \u2014 these are non-negotiable.\n- If you find a better implementation approach than what\'s in the plan, use it. Document every deviation in handoff.md under "Deviations" with specific rationale.\n- You may NOT silently drop an AC, skip a required validation check, or omit a spec requirement.\n- If an AC is infeasible as written, document it in Blockers \u2014 do not silently skip.\n- If an AC is ambiguous enough that two reasonable implementations exist, document your interpretation in handoff.md under Blockers with label `[ambiguity]` \u2014 do not silently guess. Claude will evaluate whether the interpretation was correct.\n\n## Implementation Rules\n\n**Safe-First Rules** \u2014 always applicable regardless of stack:\n1. For storage, reload, sync, or data-affecting flows: ship the safer guarded behavior first.\n2. Behavior that reloads the app, replaces local state, or dismisses user work must be gated by explicit user action.\n3. Prefer shared types over duplicating signatures.\n\n**Scope Discipline** \u2014 always applicable; the spec is the contract:\n1. **Affected Files is the scope cap.** If satisfying an AC genuinely requires editing files outside the spec\'s *Affected Files* table, do not make that edit. Record the gap in `handoff.md` under *Blockers* \u2014 the handoff is how it reaches a human \u2014 then finish the remaining in-scope work, the handoff, and the phase command. Do not silently expand scope. New helpers, fixtures, and test files introduced during implementation count against this cap too.\n2. **No unauthorized new abstractions.** Do not introduce new top-level modules, services, packages, or routing layers that the spec did not authorize. Minor refactors within an authorized file are fine; new abstractions are an architecture decision and belong in the spec.\n3. **No incidental dependency changes.** Do not add, remove, upgrade, or downgrade dependencies (or their pinned versions) unless the spec explicitly requests it.\n\n**Lint & Type Safety Policy** \u2014 always applicable:\n1. **Suppressing a lint or type error is a last resort**, not a convenience escape hatch. Never add a suppression without a same-line justification explaining *why the rule is wrong for this specific case*.\n2. **`any` / dynamic typing**: When the shape is truly unknown at the boundary, type as `unknown` and narrow explicitly.\n\n**Bug/Flake-Fix Red-First Checkpoint** \u2014 applicable when a spec\'s ACs include a red-first regression test:\nWrite the test and run it against the pre-fix code first; confirm it fails *for the reason the spec states*, then apply the fix and confirm it passes. Report the red run (command + observed failure) in handoff.md. If the test cannot be made to fail on the pre-fix code for the stated reason, do not implement a fix on a premise you could not reproduce \u2014 record a `[wrong-premise]` Blocker in handoff.md instead, then finish the remaining in-scope work, the handoff, and the phase command. If the spec instead uses the environment-bound-and-impractical escape, run its named deterministic alternative before fixing if it is executable in your sandbox (e.g. an integration fixture) and report the outcome in handoff.md the same way; if it is not executable (e.g. a documented manual repro), state that in handoff.md instead \u2014 never report an outcome for a run that did not happen.\n\n**Parsing Structured Input** \u2014 always applicable when implementing a parser for author-facing structured input:\nParse cell-by-cell with explicit rejection, not a permissive whole-string regex. Anchor each cell to exactly one expected shape and reject malformed cells with a specific reason at the parse boundary.\n\nRun ALL applicable validation checks before writing handoff. See "Validation Required" in each spec.md. The universal change-type \u2192 check-category matrix:\n\n| Change Type | Required Check Categories |\n|---|---|\n| Most changes | Linting, type checking, unit tests |\n| Docs references | Docs references |\n| Routes / config / build | Full build |\n| UI / interaction changes | End-to-end tests |\n| Content / SEO / metadata | Prerender / sitemap / feed regeneration |\n| Schema / migration | Migration runner + manual review |\n| Cross-platform | Subset of the above on each platform |\n\nFor which command runs each category: see `docs/architecture.md` \xA7Validation (project command bindings). Required checks must be recorded as Pass or Fail; do not mark a required check N/A unless the spec explicitly removed it.\n\n**Test flakiness in your sandbox.** Validation suites \u2014 especially E2E or integration tests \u2014 can hit transient failures (timing races, environment quirks, network jitter) that have nothing to do with the code in your spec\'s Affected Files. **If a failure is in a test / file outside your Affected Files table, do NOT fix it.** Note the observed test name, file, line, and a one-line repro hint in handoff.md \u2192 Blockers (or "Validation Outcomes" Notes column with status `Fail \u2013 unrelated`), then continue. `Fail \u2013 unrelated` is only valid for failures in files outside your Affected Files; a failure in a file you changed is yours to fix. Scope discipline > fixing adjacent bugs you spot during validation. The reviewer/operator will decide whether to triage the unrelated failure separately.\n\nFor each task, write tasks/<id>/handoff.md using the template. The Validation Outcomes table must have no Fail results EXCEPT for unrelated-flake rows clearly labeled in the Notes column.\nAppend to tasks/<id>/notes.md for any surprising codebase behavior (prefix: [implement]).\n\nWhen done, run:\n{{{phaseCommands}}}\n';
 
 // src/orchestrator/prompts/templates/implement-reroute.md
 var implement_reroute_default = "A human wrote a spec amendment and rerouted {{taskScope}} for {{projectName}}.\n\n{{{stateHeader}}}\n{{{roundBanner}}}{{{preamble}}}\n\n{{#startup}}{{{startup}}}\n{{/startup}}{{{risksBlock}}}{{{pitfallsBlock}}}{{{contextBlock}}}\n{{{affectedFilesBlock}}}\nTasks with amended specs:\n{{{taskLines}}}\n\n{{{groundingRule}}}\n\n**How to approach this:**\n0. If a task's line above marks it EXEMPT, skip steps 1-2 for that task entirely \u2014 its spec has NO Amendment section and its plan has NO Reroute Plan section, by design. For exempt tasks, follow the task-specific line above: approved siblings only need shared-behavior re-verification, while siblings with prior review findings must still address those findings.\n1. For each task above, read `tasks/<id>/spec.md` from your current working directory (the worktree). REPO_ROOT's copy is the pre-implement scaffold and does NOT contain operator amendments. Locate the exact heading named in its entry \u2014 `## Amendment` for round 1, or `## Amendment Round N` for round 2+. Each task carries its own reroute round (bundles may mix rounds), so use the heading specified in that task's line, not a bundle-wide assumption. Treat that section's content as the new requirements; ignore prior-round sections when implementing this one.\n2. Check `tasks/<id>/plan.md` for `## Reroute Plan` (round 1) or `## Reroute Plan Round N` (N = that task's reroute round). If present, use that section as the delta guide. If absent (fast-tier reroute with no conversational reroute plan), read the base plan for orientation.\n3. Read tasks/<id>/handoff.md to understand what you previously shipped. Do NOT assume the handoff covers the amendment \u2014 it was written before the amendment existed.\n4. Identify the delta: which ACs are new, which changed, which were already addressed by the previous implementation.\n5. Implement the delta. Previously-correct work stays; only change what the amendment requires. If the amendment conflicts with a prior AC, the amendment wins.\n6. Re-run ALL applicable validation checks (lint, type-check, test, build, e2e as applicable per the spec's Validation Required). Required checks must be recorded as Pass or Fail; do not mark a required check N/A.\n7. **Rewrite handoff.md** to reflect the complete current state of the implementation \u2014 including the round-1 work that still applies plus the new amendment work. The reviewer reads handoff.md as the single source of truth, not your prior session's context.\n\n**Spec ACs are binding** \u2014 including both original ACs and amendment ACs. If you think an amendment AC is infeasible as written, document it under Blockers in handoff.md. Do not silently drop any AC.\n\n**Bug/flake-fix red-first checkpoint** \u2014 if the amendment adds or modifies a red-first regression-test AC: write and run the test against the task's current state **before** making this round's fix edits, and confirm it fails *for the reason the spec states*; then apply the fix and confirm it passes. Report the red run in handoff.md. If it cannot be made to fail for that reason, record a `[wrong-premise]` Blocker instead of implementing on an unconfirmed premise. If the amendment instead relies on the environment-bound-and-impractical escape, run its named deterministic alternative if it is executable in your sandbox and report the outcome in handoff.md; if it is not executable (e.g. a documented manual repro), state that instead \u2014 never report an outcome for a run that did not happen.\n\nAppend to tasks/<id>/notes.md for any surprising behavior found while re-reading the codebase (prefix: `[implement-reroute]`).\n\nWhen done, run:\n{{{phaseCommands}}}\n";
@@ -4882,7 +5056,7 @@ function bundleHasRealPriorReview(taskIds) {
   return taskIds.every((taskId) => {
     const reviewPath = path11.join(taskDirFor(taskId), "review.md");
     try {
-      const content = fs11.readFileSync(reviewPath, "utf8");
+      const content = fs12.readFileSync(reviewPath, "utf8");
       const hasH2 = /^## Stage 1\b/m.test(content);
       const hasNested = /^## Round \d+\b/m.test(content) && /^### Stage 1\b/m.test(content);
       return (hasH2 || hasNested) && !content.includes("[TASK-ID]");
@@ -4891,20 +5065,24 @@ function bundleHasRealPriorReview(taskIds) {
     }
   });
 }
-function promptCodeReview(state, baseBranch, scopedDiff = null, coldCodexFindings = null) {
-  const { tasks } = state;
+function resolveCodeReviewRound(tasks) {
   const rawMaxIter = tasks.reduce((max, t) => Math.max(max, t.iterations), 0);
   const maxIter = bundleHasRealPriorReview(tasks.map((t) => t.taskId)) ? rawMaxIter : 0;
+  return { isRound1: maxIter === 0, roundN: maxIter + 1, maxIter };
+}
+function promptCodeReview(state, baseBranch, scopedDiff = null, coldCodexFindings = null, scopeInfo = null, outOfScopeFiles = []) {
+  const { tasks } = state;
+  const { maxIter, isRound1, roundN } = resolveCodeReviewRound(tasks);
   const resolvedBaseBranch = baseBranch ?? getBaseBranch(tasks.map((t) => t.taskId));
-  const hasDiff = scopedDiff !== null;
-  const isRound1 = maxIter === 0;
-  const roundN = maxIter + 1;
+  const isDeltaScope = scopeInfo?.scope === "delta";
+  const effectiveScopedDiff = isDeltaScope ? null : scopedDiff;
+  const hasDiff = effectiveScopedDiff !== null;
   const priorIteration = maxIter;
   const diffView = hasDiff ? {
     hasDiff,
     baseBranch: resolvedBaseBranch,
-    diffContent: scopedDiff.diff,
-    diffTruncated: scopedDiff.truncated
+    diffContent: effectiveScopedDiff.diff,
+    diffTruncated: effectiveScopedDiff.truncated
   } : {
     hasDiff,
     baseBranch: resolvedBaseBranch,
@@ -4929,8 +5107,18 @@ function promptCodeReview(state, baseBranch, scopedDiff = null, coldCodexFinding
     maxIter,
     tightenLine,
     ...diffView,
+    isDeltaScope,
+    scopeWord: isDeltaScope ? "Delta" : "Full",
+    scopeBase: scopeInfo?.base ?? resolvedBaseBranch,
+    scopeReason: scopeInfo?.reason === "delta" ? "small fix within the files already under review" : scopeInfo?.reason ?? (isRound1 ? "Round 1 (initial review)" : "full review"),
+    deltaBase: scopeInfo?.base ?? "",
+    deltaDiffContent: scopeInfo?.deltaDiff?.diff ?? "",
+    hasDeltaDiff: scopeInfo?.deltaDiff !== null && scopeInfo?.deltaDiff !== void 0,
+    deltaDiffTruncated: scopeInfo?.deltaDiff?.truncated ?? false,
     coldCodexFindings: coldCodexFindings ?? "",
     hasColdCodexFindings: coldCodexFindings !== null,
+    hasOutOfScopeFiles: outOfScopeFiles.length > 0,
+    outOfScopeFilesList: outOfScopeFiles.map((file) => `- \`${file}\``).join("\n"),
     phaseCommands: phaseCommands(tasks.map((t) => t.taskId), "code_review", "done", "<verdict>")
   });
 }
@@ -4953,19 +5141,19 @@ function promptQa(state, prTemplate) {
 
 // src/task/index.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import fs14 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 
 // src/orchestrator/canon-snapshot.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import fs12 from "fs";
+import fs13 from "fs";
 import path12 from "path";
 var CANON_UPSTREAM_REPO = "tstraub89/canon-ai";
 function isInstalledSourcePath(sourcePath) {
   return sourcePath.includes("/node_modules/") || sourcePath.includes("\\node_modules\\") || sourcePath.includes("/_npx/") || sourcePath.includes("\\_npx\\");
 }
 function resolveCanonVersion(explicit) {
-  return explicit ?? "3.3.0" ?? "dev";
+  return explicit ?? "3.4.0" ?? "dev";
 }
 function resolveOrchestratorCommit(repoRoot, upstreamCommit, runGitAt) {
   const ownToplevel = captureGitOutput(repoRoot, ["rev-parse", "--show-toplevel"], runGitAt);
@@ -5044,14 +5232,14 @@ function applyCanonSnapshot(status, canon) {
   return next;
 }
 function refreshCanonSnapshotAtPath(statusFilePath, options = {}) {
-  const status = JSON.parse(fs12.readFileSync(statusFilePath, "utf8"));
+  const status = JSON.parse(fs13.readFileSync(statusFilePath, "utf8"));
   const canon = captureCanonSnapshot(REPO_ROOT, options);
   const next = applyCanonSnapshot(status, canon);
   const serialized = `${JSON.stringify(next, null, 2)}
 `;
-  const current = fs12.readFileSync(statusFilePath, "utf8");
+  const current = fs13.readFileSync(statusFilePath, "utf8");
   if (current !== serialized) {
-    fs12.writeFileSync(statusFilePath, serialized, "utf8");
+    fs13.writeFileSync(statusFilePath, serialized, "utf8");
   }
   return canon;
 }
@@ -5060,7 +5248,7 @@ function refreshCanonSnapshotsAtPaths(statusFilePaths, options = {}) {
 }
 
 // src/orchestrator/quality-log.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path13 from "path";
 var CANON_LOG_HEADERS = [
   "Date",
@@ -5255,11 +5443,11 @@ function renderRowLine(headerCells, row) {
 function writeFileAtomic(filePath, content) {
   const tempPath = `${filePath}.tmp`;
   try {
-    fs13.writeFileSync(tempPath, content, "utf8");
-    fs13.renameSync(tempPath, filePath);
+    fs14.writeFileSync(tempPath, content, "utf8");
+    fs14.renameSync(tempPath, filePath);
   } finally {
     try {
-      fs13.unlinkSync(tempPath);
+      fs14.unlinkSync(tempPath);
     } catch {
     }
   }
@@ -5268,7 +5456,7 @@ function upsertQualityLogRow(logFilePath, derived, qaSupplied) {
   try {
     let content;
     try {
-      content = fs13.readFileSync(logFilePath, "utf8");
+      content = fs14.readFileSync(logFilePath, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") {
         content = STANDARD_QUALITY_LOG_SKELETON;
@@ -5327,7 +5515,7 @@ function writeQualityLogForTask(taskId, activeCwd, donePath, status) {
   try {
     let doneContent = "";
     try {
-      doneContent = fs13.readFileSync(donePath, "utf8");
+      doneContent = fs14.readFileSync(donePath, "utf8");
     } catch {
     }
     upsertQualityLogRow(
@@ -5381,7 +5569,7 @@ function taskRootForGate(cwd) {
 }
 function readJsonFile(filePath) {
   try {
-    return JSON.parse(fs14.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs15.readFileSync(filePath, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Error: failed to read ${filePath}: ${message}`);
@@ -5389,9 +5577,9 @@ function readJsonFile(filePath) {
 }
 function writeJsonAtomic(filePath, data) {
   const tmpFile = `${filePath}.tmp`;
-  fs14.writeFileSync(tmpFile, `${JSON.stringify(data, null, 2)}
+  fs15.writeFileSync(tmpFile, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  fs14.renameSync(tmpFile, filePath);
+  fs15.renameSync(tmpFile, filePath);
 }
 function writeStatusAtomic(filePath, status) {
   status.status = deriveTopLevelStatus(status);
@@ -5464,7 +5652,7 @@ function taskPhase(id, phaseArg, statusArg, verdictArg) {
   assertValidVerdict(phaseArg, verdictArg);
   const taskCwd = resolveTaskCwd(id);
   const statusPath = taskStatusFileForCwd(taskCwd, id);
-  if (!fs14.existsSync(statusPath)) {
+  if (!fs15.existsSync(statusPath)) {
     throw new Error(`Error: No status.json found for task ${id} (looked in ${taskDirForCwd(taskCwd, id)}/)`);
   }
   const status = readJsonFile(statusPath);
@@ -5526,7 +5714,7 @@ function taskPhasePreflightRejected(id, phaseArg) {
   }
   const taskCwd = resolveTaskCwd(id);
   const statusPath = taskStatusFileForCwd(taskCwd, id);
-  if (!fs14.existsSync(statusPath)) {
+  if (!fs15.existsSync(statusPath)) {
     throw new Error(`Error: No status.json found for task ${id} (looked in ${taskDirForCwd(taskCwd, id)}/)`);
   }
   const status = readJsonFile(statusPath);
@@ -5549,6 +5737,14 @@ function taskPhasePreflightRejected(id, phaseArg) {
 }
 
 // src/orchestrator/phases/code-review.ts
+function findUnjudgedFullSendFilesFromData(changedFiles, allowlist, taskIds, verdicts) {
+  if (verdicts.some((verdict) => verdict === "changes_requested" || verdict === "needs_re_review" || verdict === "spec_gap")) return [];
+  return verifyBaseDriftFromData(changedFiles, allowlist.paths, taskIds, allowlist.prefixes);
+}
+function fullSendScopeBlockReason(taskIds, files, recordedVerdicts) {
+  const verdictNote = recordedVerdicts.length > 0 ? ` Recorded code-review verdict(s): ${recordedVerdicts.join(", ")}; inspect the review before resuming.` : "";
+  return `Full-send code review left out-of-scope files unjudged: ${files.join(", ")}. Add them to a task spec's ### Affected Files table, then re-run \`canon run ${taskIds.join(" ")}\`; or reroute with a note telling the implementer to remove them.${verdictNote}`;
+}
 var defaultDeps = {
   verifyBranch,
   getBaseBranch,
@@ -5556,6 +5752,15 @@ var defaultDeps = {
   getAffectedFiles,
   verifyHandoffAgainstDiff,
   getScopedDiff,
+  getScopedDiffInRange,
+  getPathsInRange,
+  getDeltaLineStats,
+  resolveCommit,
+  isAncestorCommit,
+  getEffectiveSize: getEffectiveSize2,
+  findColdCodexArchiveForRound,
+  hasMalformedColdCodexArchive,
+  writeColdCodexArchive,
   getClaudeConfig,
   getMaxReviewLoops,
   getCodexConfig,
@@ -5684,7 +5889,7 @@ function writePreflightReviewArtifacts(tasks, preflightFailed, route) {
     const reviewPath = path15.join(taskDirFor(t.taskId), "review.md");
     let existing = "";
     try {
-      existing = fs15.readFileSync(reviewPath, "utf8");
+      existing = fs16.readFileSync(reviewPath, "utf8");
     } catch {
     }
     const hasH2Stage1 = /^## Stage 1\b/m.test(existing);
@@ -5700,7 +5905,7 @@ function writePreflightReviewArtifacts(tasks, preflightFailed, route) {
 ${blockedBlock}` : `# Code Review: ${t.taskId}
 
 ${blockedBlock}`;
-      fs15.writeFileSync(reviewPath, reviewContent2, "utf8");
+      fs16.writeFileSync(reviewPath, reviewContent2, "utf8");
       continue;
     }
     const currentPreflight = t.status.phases.code_review?.preflight_rejections_current_loop ?? 0;
@@ -5711,7 +5916,7 @@ ${blockedBlock}`;
 ---
 
 ${stub}` : stub;
-    fs15.writeFileSync(reviewPath, reviewContent, "utf8");
+    fs16.writeFileSync(reviewPath, reviewContent, "utf8");
   }
   return true;
 }
@@ -5756,11 +5961,63 @@ async function runCodeReviewPhase(state, interactive, resumeId, deps = defaultDe
     }
     return { agent: "claude", sessionId: null, exitCode: 0 };
   }
+  const allowlist = buildAffectedFilesAllowlist(taskIds, { admitManagedDocs: true });
+  const outOfScopeFiles = verifyBaseDriftFromData(
+    [...changedFiles],
+    allowlist.paths,
+    taskIds,
+    allowlist.prefixes
+  );
+  const scopeFullSend = tasks.every((t) => t.status.full_send === true);
+  if (outOfScopeFiles.length > 0 && !scopeFullSend) {
+    const reason = `Code review pre-flight found files outside the spec's Affected Files for ${taskIds.join(", ")}:
+` + outOfScopeFiles.map((file) => `  ${file}`).join("\n") + `
+Add them to the affected task spec's ### Affected Files table in the active checkout, then re-run \`canon run ${taskIds.join(" ")}\`; or reroute with a note telling the implementer to remove them.`;
+    warn(reason);
+    autoBlockPhase(taskIds, "code_review", codeReviewCheck.count, reason);
+    process.exit(2);
+  }
+  const headSha = deps.resolveCommit("HEAD", activeCwd);
+  if (!headSha) {
+    setExitReason(`Cannot start code_review for task(s) ${taskIds.join(", ")}: HEAD does not resolve to a commit.`);
+    process.exit(1);
+  }
   info(`Phase: code_review (Claude${state.isBundle ? " bundle" : ""}, iteration ${maxIter + 1})`);
   for (const t of tasks) taskPhase(t.taskId, "code_review", "in_progress");
+  const { isRound1, roundN } = resolveCodeReviewRound(tasks);
+  const effectiveSize = deps.getEffectiveSize(tasks);
+  const delicate = tasks.some((t) => t.status.delicate === true);
+  const records = !isRound1 && effectiveSize !== "XL" ? tasks.map((t) => deps.findColdCodexArchiveForRound(taskDirFor(t.taskId), roundN - 1)) : [];
+  const agreed = records.length === tasks.length && records.every((record) => record !== null && record.reviewedSha === records[0]?.reviewedSha);
+  const previousRecordsDisagree = records.length === tasks.length && records.every((record) => record !== null) && !agreed;
+  const previousArchiveMalformed = records.some((record, index) => record === null && deps.hasMalformedColdCodexArchive(taskDirFor(tasks[index].taskId)));
+  const reviewedSha = agreed ? records[0]?.reviewedSha : void 0;
+  const resolved = reviewedSha ? deps.resolveCommit(reviewedSha, activeCwd) : null;
+  const prevRecord = reviewedSha ? {
+    reviewedSha,
+    exists: resolved !== null,
+    isAncestor: resolved !== null && deps.isAncestorCommit(reviewedSha, headSha, activeCwd),
+    equalsHead: resolved !== null && resolved === headSha
+  } : null;
+  const canProbe = prevRecord?.exists === true && prevRecord.isAncestor && !prevRecord.equalsHead;
+  const scope = resolveCodeReviewScope({
+    isRound1,
+    effectiveSize,
+    delicate,
+    baseBranch,
+    prevRecord,
+    previousArchiveMalformed,
+    previousRecordsDisagree,
+    deltaPaths: canProbe ? deps.getPathsInRange(`${reviewedSha}..${headSha}`, activeCwd) : [],
+    priorChangeSetPaths: canProbe ? deps.getPathsInRange(`${baseBranch}...${reviewedSha}`, activeCwd) : [],
+    deltaFileStats: canProbe && reviewedSha ? deps.getDeltaLineStats(reviewedSha, activeCwd, headSha) : [],
+    taskIds,
+    telemetryFiles: PIPELINE_TELEMETRY_FILES
+  });
+  const deltaDiff = scope.scope === "delta" ? deps.getScopedDiffInRange(`${scope.base}..${headSha}`, activeCwd) : null;
   const coldCfg = deps.getCodexConfig("code_review", tasks);
   const coldReviewStartMs = Date.now();
-  const coldReview = await deps.runColdCodexReview(baseBranch, coldCfg.model, coldCfg.effort, activeCwd, {
+  const coldReview = await deps.runColdCodexReview(scope.base, coldCfg.model, coldCfg.effort, activeCwd, {
     taskId: taskIds.join("+"),
     phase: "code_review",
     iteration: maxIter,
@@ -5774,17 +6031,26 @@ async function runCodeReviewPhase(state, interactive, resumeId, deps = defaultDe
     process.exit(1);
   }
   for (const t of tasks) {
-    fs15.writeFileSync(
+    fs16.writeFileSync(
       path15.join(taskDirFor(t.taskId), "review-cold-codex.md"),
       coldReview.findings,
       "utf8"
     );
   }
+  for (const t of tasks) {
+    deps.writeColdCodexArchive(taskDirFor(t.taskId), {
+      round: roundN,
+      reviewedSha: headSha,
+      scope: scope.scope,
+      base: scope.base,
+      reason: scope.reason
+    }, coldReview.findings);
+  }
   info(`\u2192 cold-codex review (${taskIds.join(", ")}): ${Math.round(coldReviewDurationMs / 1e3)}s`);
   const cfg = deps.getClaudeConfig("code_review", tasks);
   const reviewResumeId = maxIter > 0 ? resumeId : null;
-  const scopedDiff = deps.getScopedDiff(baseBranch, activeCwd);
-  const result = await deps.runClaude(promptCodeReview(state, baseBranch, scopedDiff, coldReview.findings), interactive, reviewResumeId, cfg.model, cfg.effort, cfg.budget, {
+  const scopedDiff = scope.scope === "delta" ? null : deps.getScopedDiff(baseBranch, activeCwd);
+  const result = await deps.runClaude(promptCodeReview(state, baseBranch, scopedDiff, coldReview.findings, { ...scope, deltaDiff }, outOfScopeFiles), interactive, reviewResumeId, cfg.model, cfg.effort, cfg.budget, {
     taskId: taskIds.join("+"),
     phase: "code_review",
     iteration: maxIter,
@@ -5794,7 +6060,7 @@ async function runCodeReviewPhase(state, interactive, resumeId, deps = defaultDe
     const reviewPath = path15.join(taskDirFor(t.taskId), "review.md");
     let reviewContent = null;
     try {
-      reviewContent = fs15.readFileSync(reviewPath, "utf8");
+      reviewContent = fs16.readFileSync(reviewPath, "utf8");
     } catch {
     }
     if (isTemplateUnfilled(reviewContent)) {
@@ -5895,7 +6161,7 @@ async function runImplementPhase(state, interactive, resumeId, force = false) {
 }
 
 // src/orchestrator/phases/plan.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path16 from "path";
 async function runPlanPhase(state, interactive) {
   const { tasks } = state;
@@ -5914,7 +6180,7 @@ async function runPlanPhase(state, interactive) {
     const planPath = path16.join(taskDirFor(t.taskId), "plan.md");
     let planContent = null;
     try {
-      planContent = fs16.readFileSync(planPath, "utf8");
+      planContent = fs17.readFileSync(planPath, "utf8");
     } catch {
     }
     if (isTemplateUnfilled(planContent)) {
@@ -5926,7 +6192,7 @@ async function runPlanPhase(state, interactive) {
 }
 
 // src/orchestrator/phases/qa.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path17 from "path";
 async function runQaPhase(state, interactive, resolvedPrTemplate) {
   const { tasks } = state;
@@ -5948,7 +6214,7 @@ async function runQaPhase(state, interactive, resolvedPrTemplate) {
     if (isDoneMdTemplate(donePath)) {
       const salvaged = extractDoneMdFromStdout(result.capturedStdout);
       if (salvaged) {
-        fs17.writeFileSync(donePath, salvaged);
+        fs18.writeFileSync(donePath, salvaged);
         warn(`Salvaged tasks/${taskId}/done.md from captured stdout \u2014 QA sub-agent streamed content instead of using the Write tool.`);
         const phaseStatus = readStatus(taskId).phases.qa?.status ?? "pending";
         if (phaseStatus !== "done") {
@@ -6000,7 +6266,7 @@ async function runSpecPhase(state, interactive, resumeId) {
 }
 
 // src/orchestrator/phases/spec-review.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path18 from "path";
 function autoBlockSpecReview(taskIds, iterationCount, reason) {
   autoBlockPhase(taskIds, "spec_review", iterationCount, reason);
@@ -6009,14 +6275,14 @@ function recordFastTierSpecApproval(taskId) {
   const artifactPath = path18.join(taskDirFor(taskId), "spec-review.md");
   let content;
   try {
-    content = fs18.readFileSync(artifactPath, "utf8");
+    content = fs19.readFileSync(artifactPath, "utf8");
   } catch {
     return;
   }
   if (extractCheckedVerdict(content)) return;
   const checked = content.replace(/^- \[ \] (\*\*Approved\*\*)/m, "- [x] $1");
   const note = "\n> Fast tier: Codex spec review skipped \u2014 human conversational spec approval recorded by the orchestrator.\n";
-  fs18.writeFileSync(
+  fs19.writeFileSync(
     artifactPath,
     (checked !== content ? checked : `${content}
 ## Verdict
@@ -6088,7 +6354,7 @@ ${promptSpecReview(state)}` : promptSpecReview(state);
     const reviewPath = path18.join(resolveTaskCwd(t.taskId), "tasks", t.taskId, "spec-review.md");
     let reviewContent = null;
     try {
-      reviewContent = fs18.readFileSync(reviewPath, "utf8");
+      reviewContent = fs19.readFileSync(reviewPath, "utf8");
     } catch {
     }
     if (isTemplateUnfilled(reviewContent)) {
@@ -6101,7 +6367,7 @@ ${promptSpecReview(state)}` : promptSpecReview(state);
 
 // src/orchestrator/detach.ts
 import { spawn as spawn3 } from "child_process";
-import fs19 from "fs";
+import fs20 from "fs";
 import path19 from "path";
 var DETACH_CHILD_FLAG = "CANON_DETACHED";
 var DETACH_DISABLE_FLAG = "CANON_NO_DETACH";
@@ -6138,7 +6404,7 @@ function detachAndExit(options) {
   }
   const primaryDir = options.resolveTaskDir(options.taskIds[0]);
   try {
-    fs19.mkdirSync(primaryDir, { recursive: true });
+    fs20.mkdirSync(primaryDir, { recursive: true });
   } catch (error) {
     stderrWrite(`canon: cannot create task dir for log file: ${error.message}
 `);
@@ -6147,7 +6413,7 @@ function detachAndExit(options) {
   const logPath = path19.join(primaryDir, LOG_FILENAME);
   let logFd;
   try {
-    logFd = fs19.openSync(logPath, "a");
+    logFd = fs20.openSync(logPath, "a");
   } catch (error) {
     stderrWrite(`canon: cannot open ${logPath}: ${error.message}
 `);
@@ -6160,7 +6426,7 @@ function detachAndExit(options) {
     env: { ...process.env, [DETACH_CHILD_FLAG]: "1" }
   });
   try {
-    fs19.closeSync(logFd);
+    fs20.closeSync(logFd);
   } catch {
   }
   if (child.pid == null) {
@@ -6171,8 +6437,8 @@ function detachAndExit(options) {
   for (const taskId of options.taskIds) {
     try {
       const dir = options.resolveTaskDir(taskId);
-      fs19.mkdirSync(dir, { recursive: true });
-      fs19.writeFileSync(path19.join(dir, PID_FILENAME), `${child.pid}
+      fs20.mkdirSync(dir, { recursive: true });
+      fs20.writeFileSync(path19.join(dir, PID_FILENAME), `${child.pid}
 `, "utf8");
     } catch (error) {
       pidWriteFailures.push({
@@ -6228,7 +6494,7 @@ ${rule}
 function readCanonPid(taskDir) {
   const file = path19.join(taskDir, PID_FILENAME);
   try {
-    const raw = fs19.readFileSync(file, "utf8").trim();
+    const raw = fs20.readFileSync(file, "utf8").trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -6237,7 +6503,7 @@ function readCanonPid(taskDir) {
 }
 function removeCanonPid(taskDir) {
   try {
-    fs19.unlinkSync(path19.join(taskDir, PID_FILENAME));
+    fs20.unlinkSync(path19.join(taskDir, PID_FILENAME));
   } catch {
   }
 }
@@ -6499,16 +6765,14 @@ function autoCommitCode(taskIds, cwd = REPO_ROOT2) {
   const toStage = handoffFiles.filter((f) => dirtyFiles.has(f));
   const gitIgnoredHandoffFiles = filterGitIgnoredPaths(handoffFiles, cwd);
   const missing = [];
-  const settledDeletions = /* @__PURE__ */ new Set();
   const baseRefForLog = getBaseBranch(taskIds);
   for (const f of allHandoffFiles) {
     if (dirtyFiles.has(f)) continue;
     if (gitIgnoredHandoffFiles.has(f)) continue;
-    const exists = fs20.existsSync(path20.join(cwd, f));
+    const exists = fs21.existsSync(path20.join(cwd, f));
     if (!exists) {
       const committed = gitSafeAt(cwd, "log", "--format=%H", "--max-count=1", `${baseRefForLog}..HEAD`, "--", f);
       if (committed.ok && committed.stdout.trim()) {
-        settledDeletions.add(f);
         continue;
       }
       missing.push(`${f} \u2014 listed in handoff but missing from working tree (and no commit in ${baseRefForLog}..HEAD touches this path)`);
@@ -6544,14 +6808,11 @@ ${stagedBeforeUnexpected.map((f) => `    ${f}`).join("\n")}
     info("Handoff files are already committed or unchanged \u2014 skipping auto-commit.");
     return;
   }
-  const stageable = handoffFiles.filter((f) => !settledDeletions.has(f));
-  if (stageable.length === 0) {
-    verifyHandoffFilesCommitted(taskIds, cwd, handoffFiles);
-    info("All handoff files are already settled in history \u2014 skipping auto-commit.");
-    return;
+  const stageable = filterStageablePaths(handoffFiles, cwd);
+  if (stageable.length > 0) {
+    const addResult = gitSafeAt(cwd, "add", "-A", "--", ...stageable);
+    if (!addResult.ok) die2(`Failed to stage files: ${addResult.stderr || "unknown error"}`);
   }
-  const addResult = gitSafeAt(cwd, "add", "-A", "--", ...stageable);
-  if (!addResult.ok) die2(`Failed to stage files: ${addResult.stderr || "unknown error"}`);
   const preCheck = gitSafeAtRaw(cwd, "status", "--porcelain=v1", "-uall");
   const remaining = preCheck.ok ? findUncoveredTrackedChanges(preCheck.stdout, allHandoffFiles) : [];
   const stagedAfter = gitSafeAt(cwd, "diff", "--cached", "--name-only");
@@ -6702,8 +6963,8 @@ function exemptNodeModulesPath(entry, cwd, resolvedWorkspaceDirs) {
   let cwdReal;
   let repoRootReal;
   try {
-    cwdReal = fs20.realpathSync(cwd);
-    repoRootReal = fs20.realpathSync(REPO_ROOT2);
+    cwdReal = fs21.realpathSync(cwd);
+    repoRootReal = fs21.realpathSync(REPO_ROOT2);
   } catch {
     return null;
   }
@@ -6767,7 +7028,7 @@ function findPullRequestTemplate(repoRoot) {
     path20.join(repoRoot, "PULL_REQUEST_TEMPLATE.md")
   ];
   for (const candidate of candidates) {
-    if (fs20.existsSync(candidate)) return candidate;
+    if (fs21.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -6787,7 +7048,7 @@ function resolveQaPrBody(taskIds, activeCwd) {
   }
   return {
     kind: "fallback",
-    reason: fs20.existsSync(prBodyPath) ? "pr-body.md is still the stub template" : "pr-body.md not found"
+    reason: fs21.existsSync(prBodyPath) ? "pr-body.md is still the stub template" : "pr-body.md not found"
   };
 }
 function commitQaArtifacts(taskIds, cwd) {
@@ -6832,7 +7093,7 @@ Source or test edits must be committed during the implement phase, not left dirt
 ` + stagedBeforeUnexpected.map((filePath) => `    ${filePath}`).join("\n")
     );
   }
-  for (const relPath of stagePaths) {
+  for (const relPath of filterStageablePaths([...stagePaths], cwd)) {
     const exclusions = nodeModulesExclusionArgs(relPath, exemptNodeModulesPaths);
     const addResult = gitSafeAt2(cwd, "add", "-A", "--", relPath, ...exclusions);
     if (!addResult.ok) {
@@ -6915,8 +7176,8 @@ function recordPinnedPRNumber(taskIds, prNum) {
   if (alreadyPinned) return;
   for (const taskId of taskIds) {
     const sidecarPath = sidecarPathFor(taskId);
-    fs20.mkdirSync(path20.dirname(sidecarPath), { recursive: true });
-    fs20.writeFileSync(sidecarPath, String(prNum), "utf8");
+    fs21.mkdirSync(path20.dirname(sidecarPath), { recursive: true });
+    fs21.writeFileSync(sidecarPath, String(prNum), "utf8");
   }
 }
 function reportOrCreatePR(taskIds, branchName) {
@@ -7037,7 +7298,7 @@ function commitHumanReviewFiles(taskIds, cwd, createPR) {
     );
   }
   const docsRefsScript = path20.join(REPO_ROOT2, "scripts", "docs-refs-check.mjs");
-  if (fs20.existsSync(docsRefsScript)) {
+  if (fs21.existsSync(docsRefsScript)) {
     const docsRefsResult = spawnSync6("node", [docsRefsScript], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -7067,27 +7328,12 @@ This failure cannot be bypassed with --force.`
     );
   } else if (baseDriftResult.drift.length > 0) {
     if (!cliArgs.force) {
-      die2(
-        `--pr aborted: base-drift detected. Files in the tree diff between origin/${baseBranch}
-and HEAD that are not in the spec's Affected Files (and not task-dir/telemetry):
-${baseDriftResult.drift.map((filePath) => `  ${filePath}`).join("\n")}
-The allowlist is: tasks/<id>/**, PIPELINE_TELEMETRY_FILES, files listed in
-your spec's '### Affected Files' table (directory-form entries like 'dist/' match
-subpaths), and PIPELINE_MANAGED_DOCS (auto-allowlisted once qa.status = done).
-If this is a legitimate task change, add the path to spec.md '### Affected Files'
-and rerun. For a rename, list BOTH the old and new paths. If the drift is
-unexpected (likely cross-pipeline contamination from a sibling worktree's
-managed-doc sync, OR a third-party commit landed on origin/${baseBranch} while
-this pipeline was running), recover with one of:
-  - rebase onto current origin/${baseBranch} to absorb the base advance:
-      git fetch origin ${baseBranch} && git rebase origin/${baseBranch}
-  - reset a specific file to base's content if a stray task-branch commit
-    introduced it:
-      git checkout origin/${baseBranch} -- <path> && git commit -m 'revert drift on <path>'
-  - revert the offending task-branch commit entirely:
-      git revert <sha>
-Bypass with --force if you've verified the drift is intentional.`
+      const taskChangedFiles = new Set(getAffectedFiles(`origin/${baseBranch}`, cwd));
+      const classification = classifyBaseDriftFilesFromData(
+        baseDriftResult.drift,
+        taskChangedFiles
       );
+      die2(buildBaseDriftAbortMessage(baseBranch, classification));
     }
     warn2(
       `--force override: base-drift detected; proceeding at user request. Drifted files:
@@ -7191,7 +7437,7 @@ If this is a source or test file, it should have been committed during the imple
   Unstage them or list them in the task artifacts before rerunning.`
     );
   }
-  for (const relPath of stagePaths) {
+  for (const relPath of filterStageablePaths([...stagePaths], cwd)) {
     const exclusions = nodeModulesExclusionArgs(relPath, exemptNodeModulesPaths);
     const addResult = gitSafeAt2(cwd, "add", "-A", "--", relPath, ...exclusions);
     if (!addResult.ok) {
@@ -7399,7 +7645,7 @@ function readSidecarPRNumber(taskId, taskDir = taskDirFor2(taskId)) {
   const sidecarPath = sidecarPathFor(taskId, taskDir);
   let raw;
   try {
-    raw = fs20.readFileSync(sidecarPath, "utf8").trim();
+    raw = fs21.readFileSync(sidecarPath, "utf8").trim();
   } catch {
     return null;
   }
@@ -7546,7 +7792,7 @@ function mergeOpenPRsAndPull(taskIds, baseBranch, branchByTaskId) {
 }
 function runPostMergeHook() {
   const hookPath = path20.join(REPO_ROOT2, ".canon/hooks/post-merge.sh");
-  if (!fs20.existsSync(hookPath)) return;
+  if (!fs21.existsSync(hookPath)) return;
   info2("Running .canon/hooks/post-merge.sh...");
   const result = runCommand2("bash", [hookPath]);
   if (!result.ok) {
@@ -7574,8 +7820,8 @@ function rewriteArchivedTaskRefs(taskIds) {
     path20.join(REPO_ROOT2, "docs", "task-quality-log.md")
   ];
   for (const filePath of targets) {
-    if (!fs20.existsSync(filePath)) continue;
-    let content = fs20.readFileSync(filePath, "utf8");
+    if (!fs21.existsSync(filePath)) continue;
+    let content = fs21.readFileSync(filePath, "utf8");
     let changed = false;
     for (const taskId of taskIds) {
       const stale = `tasks/${taskId}/`;
@@ -7586,7 +7832,7 @@ function rewriteArchivedTaskRefs(taskIds) {
       }
     }
     if (changed) {
-      fs20.writeFileSync(filePath, content, "utf8");
+      fs21.writeFileSync(filePath, content, "utf8");
       info2(`Updated stale task refs in ${path20.relative(REPO_ROOT2, filePath)}.`);
     }
   }
@@ -7620,7 +7866,7 @@ function classifyAndPreserveSharedDocDirt() {
     if (porcelainCode !== " M") {
       return { relPath, docClass, porcelainCode, headContent: null, workingContent: null };
     }
-    const workingContent = fs20.readFileSync(path20.join(REPO_ROOT2, relPath), "utf8");
+    const workingContent = fs21.readFileSync(path20.join(REPO_ROOT2, relPath), "utf8");
     const headResult = gitSafeAtRaw(REPO_ROOT2, "show", `HEAD:${relPath}`);
     return {
       relPath,
@@ -7637,11 +7883,11 @@ function classifyAndPreserveSharedDocDirt() {
   }
   const preserve = verdict.preserve;
   if (preserve.length === 0) return [];
-  const backupDir = fs20.mkdtempSync(path20.join(os.tmpdir(), "canon-ship-shared-doc-backup-"));
+  const backupDir = fs21.mkdtempSync(path20.join(os.tmpdir(), "canon-ship-shared-doc-backup-"));
   const preserved = [];
   for (const { relPath, suffix } of preserve) {
     const backupPath = path20.join(backupDir, relPath.replace(/[\\/]/g, "__"));
-    fs20.writeFileSync(backupPath, suffix, "utf8");
+    fs21.writeFileSync(backupPath, suffix, "utf8");
     info2(`Preserving uncommitted ${relPath} dirt during --ship; backup: ${backupPath}`);
     const checkoutResult = gitSafe("checkout", "HEAD", "--", relPath);
     if (!checkoutResult.ok) {
@@ -7669,7 +7915,7 @@ function shipTasks(taskIds) {
       path20.join(taskDirForRepoRoot2(taskId), "status.json")
     ];
     for (const candidate of candidates) {
-      if (fs20.existsSync(candidate)) return readStatusFromPath(candidate, taskId);
+      if (fs21.existsSync(candidate)) return readStatusFromPath(candidate, taskId);
     }
     const snapshot = taskStatuses.get(taskId);
     if (snapshot) return snapshot;
@@ -7810,7 +8056,7 @@ Recovery:
     );
   }
   const archiveDir = path20.join(TASKS_DIR2, "_archive");
-  if (!fs20.existsSync(archiveDir)) fs20.mkdirSync(archiveDir, { recursive: true });
+  if (!fs21.existsSync(archiveDir)) fs21.mkdirSync(archiveDir, { recursive: true });
   const localBranchesToDelete = [];
   for (const taskId of taskIds) {
     const { worktree: hasWorktree } = taskSnapshot(taskId);
@@ -7822,7 +8068,7 @@ Recovery:
     writeStatusToFile(path20.join(REPO_ROOT2, "tasks", taskId, "status.json"), status);
     const src = taskDirForRepoRoot2(taskId);
     const dest = path20.join(archiveDir, taskId);
-    fs20.renameSync(src, dest);
+    fs21.renameSync(src, dest);
     info2(`\u{1F4E6} ${taskId} \u2192 tasks/_archive/${taskId}`);
     const branchName = taskSnapshot(taskId).branch;
     if (branchExistsLocally(branchName)) localBranchesToDelete.push(branchName);
@@ -7838,8 +8084,8 @@ Recovery:
   ]);
   stageArchiveChanges(stagedPaths);
   for (const { relPath, suffix, backupPath } of preservedSharedDocDirt) {
-    fs20.appendFileSync(path20.join(REPO_ROOT2, relPath), suffix, "utf8");
-    fs20.rmSync(backupPath, { force: true });
+    fs21.appendFileSync(path20.join(REPO_ROOT2, relPath), suffix, "utf8");
+    fs21.rmSync(backupPath, { force: true });
     info2(`Re-applied preserved ${relPath} dirt as uncommitted changes; backup removed.`);
   }
   const archiveCommit = commitArchiveChanges(taskIds, baseBranch);
@@ -8090,7 +8336,7 @@ async function runPhase(phase, state) {
   if (phase === "qa") {
     const activeCwd = getActiveCwd(taskIds);
     const qaTemplatePath = state.isBundle ? null : findPullRequestTemplate(activeCwd) ?? findPullRequestTemplate(REPO_ROOT2);
-    const resolvedPrTemplate = qaTemplatePath ? fs20.readFileSync(qaTemplatePath, "utf8") : null;
+    const resolvedPrTemplate = qaTemplatePath ? fs21.readFileSync(qaTemplatePath, "utf8") : null;
     return runQaPhase(state, cliArgs.interactive, resolvedPrTemplate);
   }
   if (phase === "human_review") {
@@ -8173,7 +8419,7 @@ var extractCheckedVerdict2 = extractCheckedVerdict;
 function readArtifact(taskId, name) {
   const p = path20.join(taskDirFor2(taskId), name);
   try {
-    return fs20.readFileSync(p, "utf8");
+    return fs21.readFileSync(p, "utf8");
   } catch {
     return null;
   }
@@ -8197,7 +8443,7 @@ function checkImplementEvidence(taskId) {
   const sForEvidence = readStatus(taskId);
   if (sForEvidence.worktree === true) {
     const wt = worktreePath(taskId);
-    if (fs20.existsSync(wt)) checkRoots.push(wt);
+    if (fs21.existsSync(wt)) checkRoots.push(wt);
   }
   const ignoreCwd = checkRoots[checkRoots.length - 1];
   const gitIgnored = filterGitIgnoredPaths(files, ignoreCwd);
@@ -8209,12 +8455,13 @@ function checkImplementEvidence(taskId) {
     };
   }
   const existingFiles = verifiableFiles.filter(
-    (f) => checkRoots.some((root) => fs20.existsSync(path20.join(root, f)))
+    (f) => checkRoots.some((root) => fs21.existsSync(path20.join(root, f)))
   );
   if (existingFiles.length === 0) {
     const evidenceCwd = checkRoots[checkRoots.length - 1];
-    const deletedInWorkingTree = new Set(
-      gitSafeAt(evidenceCwd, "ls-files", "--deleted").stdout.split("\n").map((l) => l.trim()).filter(Boolean)
+    const deletedDiff = gitSafeAt(evidenceCwd, "diff", "HEAD", "--name-only", "--no-renames", "--diff-filter=D");
+    const deletedAgainstHead = new Set(
+      (deletedDiff.ok ? deletedDiff.stdout : "").split("\n").map((l) => l.trim()).filter(Boolean)
     );
     const baseBranch = sForEvidence.base_branch || getDefaultBaseBranch();
     const committedDiff = gitSafeAt(
@@ -8227,7 +8474,7 @@ function checkImplementEvidence(taskId) {
       committedDiff.stdout.split("\n").filter((l) => l.startsWith("D")).map((l) => l.split("	")[1]?.trim()).filter((p) => Boolean(p))
     );
     const deletedFiles = verifiableFiles.filter(
-      (f) => deletedInWorkingTree.has(f) || deletedInCommits.has(f)
+      (f) => deletedAgainstHead.has(f) || deletedInCommits.has(f)
     );
     if (deletedFiles.length === 0) {
       return { advanced: false, note: `handoff.md lists ${files.length} file(s) but none exist on disk or are git-tracked deletions` };
@@ -8430,6 +8677,35 @@ async function checkAndRoute(phase, taskIds) {
     }
   }
   statuses = taskIds.map(readStatus);
+  let specGapScopeFiles = [];
+  if (phase === "code_review" && statuses.every((status) => status.full_send === true)) {
+    const cwd = getActiveCwd(taskIds);
+    const baseBranch = getBaseBranch(taskIds);
+    const changedFiles = getAffectedFiles(baseBranch, cwd);
+    const allowlist = buildAffectedFilesAllowlist(taskIds, { admitManagedDocs: true });
+    const verdicts = statuses.map((status) => getVerdict(status, "code_review"));
+    if (verdicts.includes("spec_gap")) {
+      specGapScopeFiles = verifyBaseDriftFromData(
+        changedFiles,
+        allowlist.paths,
+        taskIds,
+        allowlist.prefixes
+      );
+    }
+    const unjudged = findUnjudgedFullSendFilesFromData(
+      changedFiles,
+      allowlist,
+      taskIds,
+      verdicts
+    );
+    if (unjudged.length > 0) {
+      const reason = fullSendScopeBlockReason(taskIds, unjudged, verdicts.filter(Boolean));
+      warn2(reason);
+      const maxIter = statuses.reduce((max, status) => Math.max(max, getIterations(status)), 0);
+      autoBlockPhase(taskIds, "code_review", maxIter, reason);
+      process.exit(2);
+    }
+  }
   if (lastCodexExitStatus !== 0) {
     warn2(`Phase '${phase}' completed despite Codex exit status ${lastCodexExitStatus} (likely MCP warnings). Continuing.`);
     lastCodexExitStatus = 0;
@@ -8505,7 +8781,8 @@ async function checkAndRoute(phase, taskIds) {
       const specGapIds = taskIds.filter((_, index) => getVerdict(statuses[index], "code_review") === "spec_gap");
       if (specGapIds.length > 0) {
         const maxIter = statuses.reduce((max, s) => Math.max(max, getIterations(s)), 0);
-        const reason = `Code review surfaced a spec_gap verdict for task(s): ${specGapIds.join(", ")}. The implementation cannot resolve this \u2014 the root cause is in the spec. Recovery options (both operate on the full blocked bundle [${taskIds.join(" ")}]):
+        const scopeNote = specGapScopeFiles.length > 0 ? ` Full-send files remain outside Affected Files: ${specGapScopeFiles.join(", ")}. A BLESS accepts the verdict but does not amend the spec, so --pr will still reject these files: before blessing, add them to the spec's Affected Files (as an ## Amendment) or remove them from the branch.` : "";
+        const reason = `Code review surfaced a spec_gap verdict for task(s): ${specGapIds.join(", ")}. The implementation cannot resolve this \u2014 the root cause is in the spec. ` + scopeNote + `Recovery options (both operate on the full blocked bundle [${taskIds.join(" ")}]):
   FIX: amend spec.md with ## Amendment, then: canon run ${taskIds.join(" ")} --reroute
   BLESS: canon task accept ${taskIds.join(" ")} code_review --reason "<why>"`;
         console.log("");
@@ -8515,6 +8792,12 @@ async function checkAndRoute(phase, taskIds) {
         console.log("  The code review found a problem in the spec, not a fixable");
         console.log("  implementation bug. Review the findings:");
         for (const id of specGapIds) console.log(`    tasks/${id}/review.md`);
+        if (specGapScopeFiles.length > 0) {
+          console.log("  Full-send files still outside Affected Files:");
+          for (const file of specGapScopeFiles) console.log(`    ${file}`);
+          console.log("  BLESS does not amend the spec, so --pr will still reject these files.");
+          console.log("  Before blessing, add them to Affected Files (## Amendment) or remove them.");
+        }
         console.log("");
         console.log("  Two recovery options:");
         console.log("");
@@ -8565,8 +8848,8 @@ function checkDeps(taskIds, skipAgentDeps = false) {
   for (const taskId of taskIds) {
     validateTaskId(taskId);
     const repoRootStatusFile = path20.join(REPO_ROOT2, "tasks", taskId, "status.json");
-    const statusFile = cliArgs.ship && fs20.existsSync(repoRootStatusFile) ? repoRootStatusFile : statusFileFor(taskId);
-    if (!fs20.existsSync(statusFile)) {
+    const statusFile = cliArgs.ship && fs21.existsSync(repoRootStatusFile) ? repoRootStatusFile : statusFileFor(taskId);
+    if (!fs21.existsSync(statusFile)) {
       die(`No status.json at tasks/${taskId}/status.json \u2014 run canon task new ${taskId} first`);
     }
   }
@@ -8608,7 +8891,7 @@ async function main() {
   let heartbeatStarted = false;
   const earlyHeartbeatResolver = (id) => {
     const repoRootStatusFile = path20.join(REPO_ROOT2, "tasks", id, "status.json");
-    return path20.dirname(cliArgs.ship && fs20.existsSync(repoRootStatusFile) ? repoRootStatusFile : statusFileFor(id));
+    return path20.dirname(cliArgs.ship && fs21.existsSync(repoRootStatusFile) ? repoRootStatusFile : statusFileFor(id));
   };
   if (!cliArgs.ship && !cliArgs.dryRun) {
     guardConcurrentRun(cliArgs.taskIds, earlyHeartbeatResolver);