canon-ai 3.3.1 → 3.5.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
@@ -356,7 +357,7 @@ var WORKTREES_ROOT = process.env.CANON_WORKTREES_ROOT ? path.resolve(REPO_ROOT,
 var STALL_TIMEOUT_MS = Number(process.env.PIPELINE_STALL_TIMEOUT_MS) || 10 * 60 * 1e3;
 var STALL_KILL_GRACE_MS = 3e3;
 var LEGACY_FALLBACK_ENV_VARS = [
-  { old: "CLAUDE_MODEL", replacement: "CLAUDE_MODEL_SPEC / _PLAN / _REVIEW (still honored as fallback for those three; not applied to qa)" },
+  { old: "CLAUDE_MODEL", replacement: "CLAUDE_MODEL_LIGHT / CLAUDE_MODEL_STRONG (still honored as a fallback for every Claude phase, including qa)" },
   { old: "CODEX_MODEL_DEFAULT", replacement: "CODEX_MODEL_MINI (still honored as fallback)" },
   { old: "CODEX_MODEL_DELICATE", replacement: "CODEX_MODEL_FULL (still honored as fallback)" }
 ];
@@ -415,15 +416,6 @@ function resolveProjectName() {
 }
 var config = {
   projectName: resolveProjectName(),
-  claudeBudget: process.env.CLAUDE_BUDGET ?? null,
-  claudeModelSpec: process.env.CLAUDE_MODEL_SPEC ?? process.env.CLAUDE_MODEL ?? "opus",
-  claudeModelPlan: process.env.CLAUDE_MODEL_PLAN ?? process.env.CLAUDE_MODEL ?? "sonnet",
-  claudeModelReview: process.env.CLAUDE_MODEL_REVIEW ?? process.env.CLAUDE_MODEL ?? "sonnet",
-  claudeModelReviewLarge: process.env.CLAUDE_MODEL_REVIEW_LARGE ?? process.env.CLAUDE_MODEL ?? "opus",
-  claudeModelQa: process.env.CLAUDE_MODEL_QA ?? process.env.CLAUDE_MODEL ?? "sonnet",
-  codexModelMini: process.env.CODEX_MODEL_MINI ?? process.env.CODEX_MODEL_DEFAULT ?? "gpt-6-luna",
-  codexModelFull: process.env.CODEX_MODEL_FULL ?? process.env.CODEX_MODEL_DELICATE ?? "gpt-6-sol",
-  maxReviewLoops: parseMaxReviewLoops(process.env.MAX_REVIEW_LOOPS),
   maxContextBytes: Number.parseInt(process.env.MAX_CONTEXT_BYTES ?? String(64 * 1024), 10)
 };
 
@@ -1329,6 +1321,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 +1419,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 +1586,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 +1623,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",
@@ -1663,7 +1724,37 @@ function codexMatrix(config3) {
     }
   };
 }
-function claudeModelFor(config3, phase) {
+var CLAUDE_CELLS = {
+  spec: {
+    XS: { tier: "light", effort: "medium" },
+    S: { tier: "light", effort: "medium" },
+    M: { tier: "strong", effort: "medium" },
+    L: { tier: "strong", effort: "medium" },
+    XL: { tier: "strong", effort: "high" }
+  },
+  plan: {
+    XS: { tier: "light", effort: "medium" },
+    S: { tier: "light", effort: "medium" },
+    M: { tier: "strong", effort: "medium" },
+    L: { tier: "strong", effort: "medium" },
+    XL: { tier: "strong", effort: "high" }
+  },
+  code_review: {
+    XS: { tier: "light", effort: "medium" },
+    S: { tier: "light", effort: "medium" },
+    M: { tier: "strong", effort: "medium" },
+    L: { tier: "strong", effort: "medium" },
+    XL: { tier: "strong", effort: "high" }
+  },
+  qa: {
+    XS: { tier: "light", effort: "medium" },
+    S: { tier: "light", effort: "medium" },
+    M: { tier: "light", effort: "medium" },
+    L: { tier: "light", effort: "medium" },
+    XL: { tier: "light", effort: "medium" }
+  }
+};
+function claudePinFor(phase, size, config3) {
   switch (phase) {
     case "spec":
       return config3.claudeModelSpec;
@@ -1671,48 +1762,36 @@ function claudeModelFor(config3, phase) {
       return config3.claudeModelPlan;
     case "qa":
       return config3.claudeModelQa;
-    // code_review is size-keyed (see codeReviewMatrix in claudeMatrix); not
-    // resolved through this helper. spec_review, implement, human_review
-    // aren't Claude phases; fall back to the spec model so resumed Claude
-    // sessions survive accidental use.
-    default:
-      return config3.claudeModelSpec;
+    case "code_review":
+      return size === "XL" ? config3.claudeModelReviewLarge : config3.claudeModelReview;
   }
 }
+function resolveClaudeModel(phase, size, config3) {
+  const pin = claudePinFor(phase, size, config3);
+  if (pin !== null) return pin;
+  const tier = CLAUDE_CELLS[phase][size].tier;
+  const tierModel = tier === "light" ? config3.claudeModelLight : config3.claudeModelStrong;
+  if (tierModel !== null) return tierModel;
+  if (config3.claudeModelLegacy !== null) return config3.claudeModelLegacy;
+  return tier === "light" ? "sonnet" : "opus";
+}
 function claudeMatrix(config3) {
-  const buildHigh = (phase, xlEffort = "xhigh") => {
-    const model = claudeModelFor(config3, phase);
-    return {
-      XS: { model, effort: "medium" },
-      S: { model, effort: "medium" },
-      M: { model, effort: "high" },
-      L: { model, effort: "high" },
-      XL: { model, effort: xlEffort }
-    };
-  };
-  const buildMedium = (phase) => {
-    const model = claudeModelFor(config3, phase);
-    return {
-      XS: { model, effort: "medium" },
-      S: { model, effort: "medium" },
-      M: { model, effort: "medium" },
-      L: { model, effort: "high" },
-      XL: { model, effort: "high" }
-    };
-  };
-  const codeReviewMatrix = () => ({
-    XS: { model: config3.claudeModelReview, effort: "medium" },
-    S: { model: config3.claudeModelReview, effort: "medium" },
-    M: { model: config3.claudeModelReview, effort: "high" },
-    L: { model: config3.claudeModelReview, effort: "high" },
-    XL: { model: config3.claudeModelReviewLarge, effort: "xhigh" }
+  const cell = (phase, size) => ({
+    model: resolveClaudeModel(phase, size, config3),
+    effort: CLAUDE_CELLS[phase][size].effort
+  });
+  const row = (phase) => ({
+    XS: cell(phase, "XS"),
+    S: cell(phase, "S"),
+    M: cell(phase, "M"),
+    L: cell(phase, "L"),
+    XL: cell(phase, "XL")
   });
   return {
-    spec: buildHigh("spec"),
-    plan: buildHigh("plan", "high"),
-    // sonnet doesn't support xhigh
-    code_review: codeReviewMatrix(),
-    qa: buildMedium("qa")
+    spec: row("spec"),
+    plan: row("plan"),
+    code_review: row("code_review"),
+    qa: row("qa")
   };
 }
 function getPipelinePolicy(tasks, config3) {
@@ -1738,11 +1817,14 @@ function getPipelinePolicy(tasks, config3) {
 
 // src/orchestrator/policy.ts
 var config2 = {
-  claudeModelSpec: process.env.CLAUDE_MODEL_SPEC ?? process.env.CLAUDE_MODEL ?? "opus",
-  claudeModelPlan: process.env.CLAUDE_MODEL_PLAN ?? process.env.CLAUDE_MODEL ?? "sonnet",
-  claudeModelReview: process.env.CLAUDE_MODEL_REVIEW ?? process.env.CLAUDE_MODEL ?? "sonnet",
-  claudeModelReviewLarge: process.env.CLAUDE_MODEL_REVIEW_LARGE ?? process.env.CLAUDE_MODEL ?? "opus",
-  claudeModelQa: process.env.CLAUDE_MODEL_QA ?? process.env.CLAUDE_MODEL ?? "sonnet",
+  claudeModelSpec: process.env.CLAUDE_MODEL_SPEC ?? null,
+  claudeModelPlan: process.env.CLAUDE_MODEL_PLAN ?? null,
+  claudeModelReview: process.env.CLAUDE_MODEL_REVIEW ?? null,
+  claudeModelReviewLarge: process.env.CLAUDE_MODEL_REVIEW_LARGE ?? null,
+  claudeModelQa: process.env.CLAUDE_MODEL_QA ?? null,
+  claudeModelLight: process.env.CLAUDE_MODEL_LIGHT || null,
+  claudeModelStrong: process.env.CLAUDE_MODEL_STRONG || null,
+  claudeModelLegacy: process.env.CLAUDE_MODEL ?? null,
   codexModelMini: process.env.CODEX_MODEL_MINI ?? process.env.CODEX_MODEL_DEFAULT ?? "gpt-6-luna",
   codexModelFull: process.env.CODEX_MODEL_FULL ?? process.env.CODEX_MODEL_DELICATE ?? "gpt-6-sol",
   maxReviewLoops: parseMaxReviewLoops(process.env.MAX_REVIEW_LOOPS),
@@ -1755,6 +1837,9 @@ function policyConfig() {
     claudeModelReview: config2.claudeModelReview,
     claudeModelReviewLarge: config2.claudeModelReviewLarge,
     claudeModelQa: config2.claudeModelQa,
+    claudeModelLight: config2.claudeModelLight,
+    claudeModelStrong: config2.claudeModelStrong,
+    claudeModelLegacy: config2.claudeModelLegacy,
     codexModelMini: config2.codexModelMini,
     codexModelFull: config2.codexModelFull,
     maxReviewLoops: config2.maxReviewLoops,
@@ -1790,15 +1875,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 +1897,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} |
 `
@@ -1824,6 +1909,7 @@ var CLAUDE_STARTUP = "Read docs/patterns.md before starting.\nSkim docs/lessons-
 var CODEX_STARTUP = 'Read docs/patterns.md and docs/codebase-map.md before starting.\nSkim docs/lessons-learned.md for entries relevant to your task area.\nRead docs/decisions.md if a settled decision governs the area you are changing, or if the task would revisit one.\nRead docs/product-context.md if the task touches user-visible behavior, product terminology, or a business rule.\nGround every claim in the current file, diff, or artifact before you state it. Do not rely on prior-session memory for code existence, validation results, or completion status.\nOn resumed sessions, re-read the task-specific files named in the prompt and inspect the current working tree before saying anything is already done.\n\nGit ownership: the pipeline orchestrator handles staging, committing, and pushing \u2014 do NOT run `git add`, `git commit`, or `git push`. Edit files in the working tree only; the orchestrator reads `git status` after your session and stages every file listed in handoff.md\'s Changes table. Read-only git is fine (`git status`, `git diff`, `git log`, `git show`).\n\nIf a code review claims a file is "missing from the commit" or "staged but not committed," that is a pipeline-orchestration issue, not an implementation issue. Record it as a Blocker in handoff.md with the `[pipeline]` label and do not retry `git add`/`git commit` to recover \u2014 the sandbox blocks `.git` writes by design, and the orchestrator owns the recovery path.\n\nCommunication: tone is project taste; honest signal is canon discipline \u2014 surface real disagreement rather than yielding to politeness.\nBranch state: the orchestrator manages it \u2014 do not fetch, pull, rebase, or push; read the working tree as-is.';
 var CODEX_HEADLESS = "Headless session: this runs non-interactively \u2014 nobody reads your messages or answers questions until the phase ends. Don't stop to ask for confirmation or clarification. When something is ambiguous, record the question and the interpretation you chose in this phase's artifact (in implement, a handoff Blocker labelled `[ambiguity]`) and proceed on it. Finish all the work this prompt authorizes before ending \u2014 acting on your own judgment never widens scope; the Affected Files cap and every other scope rule still bind. Always end by writing the phase artifact and running the phase command(s) listed at the end of this prompt, including when you recorded Blockers \u2014 a session that ends without them stalls the pipeline.\n\nIf a project instruction file or other repository guidance tells you to ask the user or wait for approval before acting, there is no one to ask in this session: record the question in the phase artifact and continue with the authorized work.";
 var QA_STARTUP = "Read CHANGELOG.md for voice and version reference, if the project keeps one.\nRead docs/lessons-learned.md for recent insights to distill.\nNo full codebase context needed for QA \u2014 read each task's spec.md, handoff.md, and notes.md directly.";
+var CLAUDE_HEADLESS = "Unattended session: this runs non-interactively \u2014 nobody reads your messages or answers questions until the phase ends. Don't stop to ask for confirmation or clarification. When something is ambiguous, record the question and the interpretation you chose in this phase's artifact or in `tasks/<id>/notes.md`, and proceed on it.\n\nThe phase is complete only when its artifact is written and its phase command (the `canon task phase` command(s) this prompt lists) has run. A progress summary, a description of next steps, or an offer to continue is not completion \u2014 keep working until both are done.\n\nDo only this phase: don't run `canon run`, advance any other phase, or start review passes, review skills, or reviewer sub-agents this prompt didn't ask for.\n\nReport a check that couldn't run, or that failed, as exactly that \u2014 never as passed.\n\nIf a project instruction file or other repository guidance says to ask or wait for approval before an action, there is no one to ask in this session. Skip that action unless this prompt explicitly authorizes it, record the question in the phase artifact, and continue with the rest of the authorized work.";
 function taskList(tasks) {
   return tasks.map((t) => `- \`${t.taskId}\`: "${t.title}" \u2192 tasks/${t.taskId}/`).join("\n");
 }
@@ -2046,7 +2132,10 @@ async function runClaude(prompt, interactive, resumeId, model, effort, budget, m
       };
     }
     const attempt = async (useResumeId) => {
-      const effectivePrompt = useResumeId ? toResumePrompt(prompt) : prompt;
+      const renderedPrompt = useResumeId ? toResumePrompt(prompt) : prompt;
+      const effectivePrompt = `${CLAUDE_HEADLESS}
+
+${renderedPrompt}`;
       const args = [
         "-p",
         effectivePrompt,
@@ -2434,7 +2523,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 +2840,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 +2927,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 +2962,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 +3107,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 +3139,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 +3193,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 +3202,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 +3248,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 +3260,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 +3298,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 +3307,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 +3328,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 +3355,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 +3657,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 +3685,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 +3745,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 +3777,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 +3806,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 +3890,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 +3908,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 +3922,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 +3953,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 +3970,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 +3997,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 +4014,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 +4030,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 +4120,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 +4137,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 +4163,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 +4247,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 +4735,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\nSpawn exactly the two Claude lenses above each round, plus at most one re-spawn of a lens whose return is missing. Spawn no other reviewers or review agents, run no review skills, and never substitute your own review for a lens's return.\n\nA lens return is valid when it follows that lens's charter return format. This includes a clean empty form (`STAGE_2_FINDINGS: (none)` or `COLD_FINDINGS: (none)`) and the anchored Stage 1 fail form (`STAGE_1: fail`, no Stage 2 findings, `OVERALL_SIGNAL: changes_requested`). A return is missing if absent or outside the charter format. Re-spawn a missing lens once with the same inputs. If still missing, do not approve or guess at its findings: it is not approval evidence. Write `review.md` recording which lens was missing and what came back, check no verdict box, then run the `code_review blocked` commands in step 5 for every task. Other lenses' findings may be recorded but not adjudicated into a verdict.\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 clean return in the charter's empty form is a valid result; only a missing return (step 1) is a lens failure. 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 (except the missing-lens stop in step 1, which checks none).\n\n### 5. Set Phase Verdict\n\nRun one command per task with the actual verdict:\n{{{phaseCommands}}}\n\nIf a lens was still missing after its re-spawn (step 1), write `review.md` first, then run these instead, with no verdict \u2014 this stops the run for the human:\n{{{blockedCommands}}}\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";
@@ -4554,10 +4747,10 @@ var implement_reroute_default = "A human wrote a spec amendment and rerouted {{t
 var implement_revisions_default = '{{{iterBanner}}}\n\n{{{stateHeader}}}\n{{{startup}}}\n\n{{{affectedFilesBlock}}}\n\n{{#hasReviewFindings}}\nYour prior iteration shipped; the reviewer (Claude) appended findings to `review.md` as `## Round {{priorRound}}`. If you\'re resuming the prior session, the full task framing (spec, plan, repo conventions) is already in context \u2014 skip the re-read. If your context is cold, re-read `tasks/<id>/spec.md` and `tasks/<id>/plan.md` before addressing findings.\n\nTasks with new review feedback:\n{{{reviewLines}}}\n\nFor each task:\n1. Read the most recent `## Round {{priorRound}}` section of `tasks/<id>/review.md`. That is the entire scope of this iteration.\n2. Address every `correctness bug`, `risk/guardrail`, and `spec gap` finding from that round (blocking). `optional cleanup/nit` is at your discretion{{#tightenLine}}{{{tightenLine}}}{{/tightenLine}}\n3. Re-run only the validation checks affected by your changes (typically lint, type-check, plus whatever the diff touches).\n4. **APPEND** to `tasks/<id>/handoff.md` a new section `{{{handoffAppend}}}` (the template\'s "On revision rounds" comment shows the shape). Do NOT rewrite the file from scratch \u2014 earlier iterations stay as the cumulative record. Include only the delta: findings addressed, AC deltas, re-run validation results.\n{{/hasReviewFindings}}\n{{#hasPreflightFindings}}\nYour prior iteration was rejected by the orchestrator\'s pre-flight gate **before any Claude review ran**. The rejection details are recorded in `review.md` under `## Validation Gate` / `## Pre-Flight Rejection`.\n\nTasks with pre-flight rejection feedback:\n{{{reviewLines}}}\n\nFor each task:\n1. Read the pre-flight block in `tasks/<id>/review.md` and follow **whichever framing it carries**:\n   - **"Fix the handoff"** items \u2192 fix `handoff.md` (Validation Outcomes rows, AC Coverage table, Changes table).\n   - **"Fix the code"** items \u2192 a required check failed on a file you changed. Fix the regression, re-run the check, and update the handoff.\n   - Both framings may be present \u2014 address all items from both before resubmitting.\n2. **APPEND** to `tasks/<id>/handoff.md` a new section `{{{handoffAppend}}}`. Include the delta: which items you addressed and how.\n{{/hasPreflightFindings}}\n\nSpec ACs remain binding. If the review identifies a dropped AC, restore it.\n\n**Iteration rules:**\n\n- **Reverting a file**: For a byte-perfect revert to the task baseline, use `git show origin/<base-branch>:<path>` (read-only git, always allowed) and write the output to the file.\n  - *Perfect revert* (file no longer in `git diff base...HEAD`): delete it from all prior iteration Changes tables in `handoff.md`.\n  - *Imperfect revert* (trailing newline or other residual remains): add it to the current iteration\'s Changes table with "Reverted to original (describe residual diff)".\n- **Referencing deleted (or not-yet-created) files in artifacts**: `docs-refs-check` flags a backtick path-ref to a file that does not exist. Referencing deleted paths in the handoff Changes-table first column must use `[path](path)` markdown-link form only \u2014 backtick form fails both checks.\n- **Rerouted / revised tasks \u2014 the pre-flight diff is cumulative**: the verifier checks the union of all Changes tables against `git diff <base>...HEAD`. Before submitting, run `git diff <base>...HEAD --name-only` and confirm every listed path is covered by at least one Changes-table row across ALL iterations.\n- **Bug/flake-fix red-first checkpoint**: if this round adds or modifies the spec\'s red-first regression test, write and run the test **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 the handoff delta. If it cannot be made to fail for that reason, do not implement around an unconfirmed premise \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 if it is executable in your sandbox and report the outcome in the handoff delta; 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 new pitfalls found (prefix: `[implement-revision]`).\n\nWhen done, run:\n{{{phaseCommands}}}\n';
 
 // src/orchestrator/prompts/templates/plan-reroute.md
-var plan_reroute_default = "You are updating the implementation plan for {{taskScope}} for {{projectName}} after a human reroute.\n\n{{{startup}}}\n\nA human amended the spec and rerouted the task after a completed implementation round. Codex has reviewed the amendment. Your job is to **append** a reroute plan section to `plan.md`; do not rewrite or remove existing plan content.\n\n{{{roundBanner}}}Amendment review verdicts:\n{{{verdictLines}}}\n\nFor each task \u2014 EXCEPT tasks whose line above marks them EXEMPT (those have no amendment; skip every step below for them and append NO Reroute Plan section to their plan.md):\n1. Read `tasks/<id>/spec.md` from your current directory, including the amendment for the round listed above.\n2. Read `tasks/<id>/plan.md` to understand the prior plan.\n3. Read `tasks/<id>/handoff.md` to understand what Codex previously shipped.\n4. Read `tasks/<id>/spec-review.md` for the latest reroute amendment review and any nits to incorporate.\n5. Append a new section to `tasks/<id>/plan.md`:\n   - Round 1: `## Reroute Plan`\n   - Round N >= 2: `## Reroute Plan Round N`\n6. Plan only the delta from the amendment. Reference specific files, functions, and existing patterns. Acknowledge prior plan steps that still apply without re-planning them.\n\nDo **not** rewrite or remove existing sections from `plan.md`. The appended reroute plan is what implement-reroute reads as its delta guide.\n\nWhen done, run:\n{{{phaseCommands}}}\n\n<!-- per-round append shape:\n## Reroute Plan [Round N]\n### Delta\n- ...ordered steps for the amendment delta only...\n-->\n";
+var plan_reroute_default = "You are updating the implementation plan for {{taskScope}} for {{projectName}} after a human reroute.\n\n{{{startup}}}\n\nA human amended the spec and rerouted the task after a completed implementation round. Codex has reviewed the amendment. Your job is to **append** a reroute plan section to `plan.md`; do not rewrite or remove existing plan content.\n\n{{{roundBanner}}}Amendment review verdicts:\n{{{verdictLines}}}\n\nFor each task \u2014 EXCEPT tasks whose line above marks them EXEMPT (those have no amendment; skip every step below for them and append NO Reroute Plan section to their plan.md):\n1. Read `tasks/<id>/spec.md` from your current directory, including the amendment for the round listed above.\n2. Read `tasks/<id>/plan.md` to understand the prior plan.\n3. Read `tasks/<id>/handoff.md` to understand what Codex previously shipped.\n4. Read `tasks/<id>/spec-review.md` for the latest reroute amendment review and any nits to incorporate.\n5. Append a new section to `tasks/<id>/plan.md`:\n   - Round 1: `## Reroute Plan`\n   - Round N >= 2: `## Reroute Plan Round N`\n6. Plan only the delta from the amendment. Reference specific files, functions, and existing patterns. Acknowledge prior plan steps that still apply without re-planning them.\n7. {{{feasibilityCheck}}}\n\nDo **not** rewrite or remove existing sections from `plan.md`. The appended reroute plan is what implement-reroute reads as its delta guide.\n\nWhen done, run:\n{{{phaseCommands}}}\n\n<!-- per-round append shape:\n## Reroute Plan [Round N]\n### Delta\n- Feasibility: ...\n- ...ordered steps for the amendment delta only...\n-->\n";
 
 // src/orchestrator/prompts/templates/plan.md
-var plan_default = "You are writing implementation plans for {{taskScope}} for {{projectName}}.\n\n{{{startup}}}\n\n{{{verdictLines}}}\n\nFor each task, read tasks/<id>/spec.md and tasks/<id>/spec-review.md. Address any `changes_requested` items before writing the plan. If the verdict is `approved_with_nits`, incorporate the nits into the plan \u2014 they don't require spec changes but should inform implementation decisions.\n\nWrite tasks/<id>/plan.md for each task with ordered implementation steps. Reference specific files, existing patterns, and code examples from the codebase. Codex implements directly from this plan.\n\nIf you encounter spec gaps, append to tasks/<id>/notes.md (prefix: [plan]).\n\nWhen done, run:\n{{{phaseCommands}}}\n";
+var plan_default = "You are writing implementation plans for {{taskScope}} for {{projectName}}.\n\n{{{startup}}}\n\n{{{verdictLines}}}\n\nFor each task, read tasks/<id>/spec.md and tasks/<id>/spec-review.md. Address any `changes_requested` items before writing the plan. If the verdict is `approved_with_nits`, incorporate the nits into the plan \u2014 they don't require spec changes but should inform implementation decisions.\n\nWrite tasks/<id>/plan.md for each task with ordered implementation steps. Reference specific files, existing patterns, and code examples from the codebase. Codex implements directly from this plan.\n\n{{{feasibilityCheck}}}\n\nIf you encounter spec gaps, append to tasks/<id>/notes.md (prefix: [plan]).\n\nWhen done, run:\n{{{phaseCommands}}}\n";
 
 // src/orchestrator/prompts/templates/qa.md
 var qa_default = 'You are writing QA summaries for {{taskScope}} for {{projectName}}.\n\n{{{startup}}}\n\nTasks:\n{{{taskLines}}}\n\nFor each task:\n1. **Use the Write tool** to create tasks/<id>/done.md \u2014 plain-English summary for the human. Include: what changed, files changed, how to test, test results, human verification required, decisions made, open questions.\n   \u26A0\uFE0F CRITICAL: Use the `Write` tool \u2014 do NOT simply output the done.md content as text in your response. Content in your chat reply does not get saved to disk. The pipeline validates that done.md contains real content (not the template) before advancing. Write the file.\n2. Read the latest `## Validation Outcomes` table in `tasks/<id>/handoff.md`, including any later iteration `### Re-run validation` tables. If any check\'s latest result is `human_pending`, include a **Human Verification Required** section in done.md that lists each pending check and its Notes. If none remain, write `None.` in that section. Do not hide `human_pending` checks inside the generic Test Results table.\n   - If the human chooses to waive or defer a pending check later, the waiver line in done.md must begin with `Acknowledged:`. The `human_review` gate only treats that explicit prefix as a waiver.\n   - Preserve `deferred_by_spec` rows in Test Results with the spec citation from Notes; do not translate them to `Pass`.\n3. Include a **Proposed Changelog** section in done.md \u2014 the changelog **entry text only**. Do **NOT** include a version number, a "Proposed version" line, or a bump tier (Patch/Minor/Major): the version is decided at the release step (`/canon-changelog` + human), never by QA.\n   - **Canon release rules (non-negotiable)**: (1) Agents do not bump versions or land changelog edits without explicit scope authorization. (2) The QA step proposes a draft changelog entry text only \u2014 not the version number. (3) Changelog + version bump are committed separately from code changes (when a project versions its releases). (4) No major versioning surprises: if a task introduces a breaking change the spec didn\'t flag, raise it before shipping.\n   - Read `docs/decisions.md` \xA7"Versioning and release policy" for this project\'s changelog **scope** (which changes warrant an entry). The bump tier / SemVer interpretation is the release step\'s call, not QA\'s \u2014 do not propose one.\n   - If CHANGELOG.md exists, read the top of it (the most recent version section) to calibrate on scope and voice.\n   - Apply the "would a user notice" test to every candidate bullet (or the project\'s equivalent scope test): if a candidate falls outside the project\'s defined changelog scope, omit it. If a task is entirely out of scope, say so explicitly ("no user-facing change \u2014 omit from changelog") rather than inventing a bullet.\n   - Implementation mechanics belong in the "What Changed" section above \u2014 not in the proposed changelog.\n   The human finalizes the changelog entry.\n4. **For single tasks only \u2014 use the Write tool** to create `tasks/<id>/pr-body.md` \u2014 the outward-facing PR body draft for `--pr`. Write it as if a human wrote it after doing the work.\n   {{#prTemplate}}\n   The repo has this PR template. Fill every section with specifics from what shipped. Keep the headings; replace every placeholder:\n\n   {{{prTemplate}}}\n   {{/prTemplate}}\n   {{^prTemplate}}\n   No PR template found. Use this structure:\n\n   ## Summary\n   1\u20133 bullets: what changed and why.\n\n   ## Changes\n   Key files or areas touched, described for a reviewer.\n\n   ## How to Test\n   Steps a reviewer can follow to verify the change.\n\n   ## Notes for Reviewer\n   Any context, caveats, or follow-up items.\n   {{/prTemplate}}\n   \u26A0\uFE0F Write as the human engineer who did the work \u2014 not as the AI or tool that produced it (Claude, Codex, canon, an LLM). \u2705 e.g. "Fix the pagination off-by-one that dropped the last row." \u274C e.g. "\u{1F916} Generated with Claude Code."\n   Skip this step entirely for bundle tasks \u2014 per-task bodies are not combined for bundle PRs.\n\nAfter writing all done.md files:\n- Read tasks/<id>/notes.md for each task. For each insight, ask: "would this have changed how a *different* task was approached?" If yes, **append** one new entry for *this* task to docs/lessons-learned.md. If no, the detail stays in notes.md only. Append-only: never edit, prune, promote, reorganize, or delete existing entries \u2014 not this task\'s earlier entries, and never another task\'s. Promoting entries into permanent docs (patterns.md / decisions.md) and pruning the buffer is a **human-initiated, human-approved** action \u2014 never perform it during QA, and no entry count ever triggers it. (See docs/lessons-learned.md \u2192 "How to use this doc".)\n- Add a `## Quality Log` section to done.md with the five judgment cells the pipeline cannot derive from status.json. Do **not** edit docs/task-quality-log.md directly \u2014 the qa \u2192 done transition writes or upserts that row automatically from status.json plus this section.\n\n  ```markdown\n  ## Quality Log\n  - Spec verdict: <the FIRST spec_review verdict this task ever received \u2014 approved / approved_with_nits / changes_requested; leave blank only if truly unknown>\n  - Human reroute?: <Yes/No \u2014 did the human reject at human_review and force a re-implement? Do not infer this from any reroute counter; if this is a fresh QA pass with no human_review rejection yet, answer No>\n  - Dropped ACs: <count of ACs the implementation missed, caught in code review>\n  - Validation gaps: <count of validation checks that should have run but did not>\n  - Notes: <one-line summary of anything notable \u2014 single line, no embedded line breaks>\n  ```\n\n  On a re-upsert after a reroute, only fill in cells that changed or that you are correcting \u2014 an omitted cell keeps its previously recorded value. In particular, do not overwrite an already-recorded `Spec verdict` with the current status.json verdict; that column means the first spec_review verdict, and status.json only retains the latest.\n\n**Handoff Validation pre-merge checklist** (include in `done.md` Human Verification section if any item cannot be confirmed):\n- [ ] Version correct (per project policy; skip if unversioned)\n- [ ] Changelog updated if needed (per project policy; skip if unversioned)\n- [ ] PR body current\n- [ ] Final CI/CD checks green\n- [ ] Final diff matches spec intent\n\n**Output Format for Human** \u2014 `done.md` must contain:\n1. One-paragraph plain-English summary\n2. Files changed\n3. How to test (product-level steps, not code)\n4. Test results table\n5. Decisions made during implementation\n6. Open questions needing human input\n\n**Code is Canonical; Docs Reference Symbols**: Code is the source of truth for anything derivable from code: numbers, thresholds, file locations, function signatures, type shapes, observable behavior. Docs that restate these facts inline rot silently \u2014 reference the symbol or path; do not restate the value.\n\n**Commit Ownership** \u2014 three change categories:\n- Code changes \u2192 task branch, committed by the orchestrator after Codex static validation.\n- Pre-implement scaffold \u2192 base branch, committed by the orchestrator before first implement.\n- Changelog + version bump (if versioned) \u2192 separate commit, human + Claude, after human_review.\n\n- **Docs freshness \u2014 Two-checkpoint**: scan the five protected docs (`docs/architecture.md`, `docs/codebase-map.md`, `docs/patterns.md`, `docs/product-context.md`, `docs/decisions.md`) for references that {{docsScope}} *contradicts* \u2014 a renamed symbol, a moved file, a behavior this task changed \u2014 and correct those stale references. That is the only edit QA makes to permanent docs. Do not add new lessons, pitfalls, or decisions here, and do not promote buffer entries \u2014 promotion is the human sweep, not Docs freshness.\n- **Buffer signal** (not an action): after appending, if docs/lessons-learned.md now holds more than ~15 entries, add one line to this task\'s done.md \u2014 `Maintenance: lessons-learned.md has N entries; a human lessons sweep is due (see docs/lessons-learned.md \u2192 "How to use this doc").` Do not perform the sweep yourself.\n\nWhen done, run (use the Bash tool \u2014 do not just output the command as text):\n{{{phaseCommands}}}\n';
@@ -4618,6 +4811,20 @@ function buildAffectedFilesBlock(affectedFiles, baseBranch) {
     ""
   ].join("\n");
 }
+function planFeasibilityCheck(placement, indent = "") {
+  const lines = [
+    `**Feasibility check.** Before writing steps, confirm each item below and record the results in a few lines ${placement}. Mark an item that doesn't apply \`N/A\` in a word.`,
+    "- **Exists:** the functions, files, and patterns the plan relies on exist \u2014 found by searching the code, not recalled.",
+    "- **Real path:** the actual runtime call path the change sits on, including any existing code on it that already does part of the work.",
+    "- **Callers:** every caller of each function whose behavior or error contract changes, found and accounted for.",
+    "- **Tests that can fail:** for each regression test the plan prescribes, the input or state that sends it through the changed path, so it fails without the change.",
+    "- **Predicates:** for each condition or state check the plan writes out, its boundary values (for example zero, empty, or non-numeric) and every state it must handle.",
+    "- **Scope:** every file the steps change is inside the spec's Affected Files.",
+    "- **Async/stateful:** for async or stateful changes \u2014 re-entry, cancellation or unmount, stale state, and ownership.",
+    "A finding that changes a step goes in that step. If the check contradicts the spec, record the contradiction in the plan and in `tasks/<id>/notes.md` with a `[plan]` prefix. Do not change the spec or widen scope to resolve it."
+  ];
+  return lines.map((line, index) => index === 0 ? line : indent + line).join("\n");
+}
 function promptSpec(state) {
   const { tasks, tier, isBundle } = state;
   const combined = tier === "fast";
@@ -4633,9 +4840,13 @@ Directory: tasks/${task.taskId}/`,
     startup: CLAUDE_STARTUP,
     instructions: isBundle ? tasks.map(
       (t) => `**Task \`${t.taskId}\`**: Write tasks/${t.taskId}/spec.md using the template.` + (combined ? ` Also write tasks/${t.taskId}/plan.md with ordered implementation steps, specific file references, and existing patterns.` : "")
-    ).join("\n\n") : `Write tasks/${task.taskId}/spec.md using the template in .canon/templates/spec.md. Be concrete \u2014 Codex implements directly from this.` + (combined ? `
+    ).join("\n\n") + (combined ? `
+
+${planFeasibilityCheck("in each plan.md's Approach section")}` : "") : `Write tasks/${task.taskId}/spec.md using the template in .canon/templates/spec.md. Be concrete \u2014 Codex implements directly from this.` + (combined ? `
+
+Also write tasks/${task.taskId}/plan.md with ordered implementation steps, specific file references, and existing patterns to use.
 
-Also write tasks/${task.taskId}/plan.md with ordered implementation steps, specific file references, and existing patterns to use.` : ""),
+${planFeasibilityCheck("in plan.md's Approach section")}` : ""),
     bundleNote: isBundle ? "\nThese tasks are related \u2014 consider cross-task interactions while speccing." : "",
     doneNote: combined ? "The orchestrator will handle spec_review and plan-phase advancement automatically for fast-tier tasks." : "",
     selfCheck: [
@@ -4643,6 +4854,7 @@ Also write tasks/${task.taskId}/plan.md with ordered implementation steps, speci
       '- Every AC is verifiable with a specific test (not just "it works" \u2014 state exactly how to verify)',
       "- Affected Files lists specific files (not directories) with specific, actionable change descriptions",
       combined ? "- Plan steps reference actual function/file names from the codebase (not just concepts)" : null,
+      combined ? "- plan.md's Approach records the feasibility check (exists, real path, callers, tests that can fail, predicates, Affected Files, async/stateful; N/A where it doesn't apply)" : null,
       "- Known Risks covers failure modes for the trickiest ACs",
       "- Human Test Plan describes product behavior only (no code, no file names, no TypeScript)",
       '- Validation Required has at least one entry checked (or explicitly "None" with a reason)',
@@ -4746,6 +4958,7 @@ function promptPlan(state) {
       taskScope: tasks.length > 1 ? "a bundle of tasks" : `task "${tasks[0].taskId}"`,
       roundBanner,
       verdictLines: verdictLines2,
+      feasibilityCheck: planFeasibilityCheck("at the top of the appended `### Delta` section", "   "),
       phaseCommands: phaseCommands(tasks.map((t) => t.taskId), "plan", "done")
     });
   }
@@ -4757,6 +4970,7 @@ function promptPlan(state) {
     startup: CLAUDE_STARTUP,
     taskScope: tasks.length > 1 ? "a bundle of tasks" : `task "${tasks[0].taskId}"`,
     verdictLines,
+    feasibilityCheck: planFeasibilityCheck("in the plan's Approach section"),
     phaseCommands: phaseCommands(tasks.map((t) => t.taskId), "plan", "done")
   });
 }
@@ -4882,7 +5096,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 +5105,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,9 +5147,20 @@ 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,
-    phaseCommands: phaseCommands(tasks.map((t) => t.taskId), "code_review", "done", "<verdict>")
+    hasOutOfScopeFiles: outOfScopeFiles.length > 0,
+    outOfScopeFilesList: outOfScopeFiles.map((file) => `- \`${file}\``).join("\n"),
+    phaseCommands: phaseCommands(tasks.map((t) => t.taskId), "code_review", "done", "<verdict>"),
+    blockedCommands: phaseCommands(tasks.map((t) => t.taskId), "code_review", "blocked")
   });
 }
 function promptQa(state, prTemplate) {
@@ -4953,19 +5182,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.1" ?? "dev";
+  return explicit ?? "3.5.0" ?? "dev";
 }
 function resolveOrchestratorCommit(repoRoot, upstreamCommit, runGitAt) {
   const ownToplevel = captureGitOutput(repoRoot, ["rev-parse", "--show-toplevel"], runGitAt);
@@ -5044,14 +5273,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 +5289,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 +5484,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 +5497,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 +5556,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 +5610,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 +5618,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 +5693,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 +5755,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 +5778,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 +5793,15 @@ var defaultDeps = {
   getAffectedFiles,
   verifyHandoffAgainstDiff,
   getScopedDiff,
+  getScopedDiffInRange,
+  getPathsInRange,
+  getDeltaLineStats,
+  resolveCommit,
+  isAncestorCommit,
+  getEffectiveSize: getEffectiveSize2,
+  findColdCodexArchiveForRound,
+  hasMalformedColdCodexArchive,
+  writeColdCodexArchive,
   getClaudeConfig,
   getMaxReviewLoops,
   getCodexConfig,
@@ -5684,7 +5930,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 +5946,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 +5957,7 @@ ${blockedBlock}`;
 ---
 
 ${stub}` : stub;
-    fs15.writeFileSync(reviewPath, reviewContent, "utf8");
+    fs16.writeFileSync(reviewPath, reviewContent, "utf8");
   }
   return true;
 }
@@ -5756,11 +6002,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 +6072,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 +6101,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 +6202,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 +6221,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 +6233,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 +6255,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 +6307,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 +6316,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 +6395,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 +6408,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 +6445,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 +6454,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 +6467,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 +6478,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 +6535,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 +6544,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 +6806,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 +6849,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 +7004,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 +7069,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 +7089,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 +7134,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 +7217,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 +7339,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 +7369,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 +7478,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 +7686,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 +7833,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 +7861,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 +7873,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 +7907,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 +7924,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 +7956,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 +8097,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 +8109,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 +8125,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 +8377,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 +8460,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 +8484,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 +8496,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 +8515,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` };
@@ -8394,8 +8682,30 @@ async function recoverPhaseForTask(taskId, phase, initialStatus) {
   warn2(`Retry did not recover '${taskId}' ${phase} (${postEvidence.note}).`);
   return false;
 }
+function stopForReviewerBlock(taskIds, blockedIds, statuses) {
+  const maxIter = statuses.reduce((max, status) => Math.max(max, getIterations(status)), 0);
+  const recovery = taskIds.map((id) => `canon task reset-code-review ${id}`).join("; ");
+  const reason = `Code review stopped without a verdict for task(s): ${blockedIds.join(", ")}. The reviewer set code_review blocked; see ${taskIds.map((id) => `tasks/${id}/review.md`).join(", ")}. No evidence recovery or retry was attempted. Recovery for the full blocked bundle [${taskIds.join(" ")}]: ${recovery}; then canon run ${taskIds.join(" ")}.`;
+  console.log("");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("  \u270B  CODE REVIEW STOPPED \u2014 the reviewer could not reach a verdict.");
+  console.log("  Read the stopped review:");
+  for (const id of taskIds) console.log(`    tasks/${id}/review.md`);
+  console.log("  Reset every task in the bundle, then run again:");
+  for (const id of taskIds) console.log(`    canon task reset-code-review ${id}`);
+  console.log(`    canon run ${taskIds.join(" ")}`);
+  console.log("  Re-running without the reset starts a fresh review pass without archiving the stopped review.md.");
+  console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("");
+  autoBlockPhase(taskIds, "code_review", maxIter, reason);
+  process.exit(2);
+}
 async function checkAndRoute(phase, taskIds) {
   let statuses = taskIds.map(readStatus);
+  if (phase === "code_review") {
+    const blockedIds = taskIds.filter((_, index) => getPhaseStatus(statuses[index], "code_review") === "blocked");
+    if (blockedIds.length > 0) stopForReviewerBlock(taskIds, blockedIds, statuses);
+  }
   for (let i = 0; i < taskIds.length; i += 1) {
     const phaseStatus = getPhaseStatus(statuses[i], phase);
     if (phase === "implement" && phaseStatus === "done") {
@@ -8430,6 +8740,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 +8844,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 +8855,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 +8911,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 +8954,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);