@anthropologies/claudestory 0.1.62 → 0.1.63

package/dist/mcp.js

@@ -133,8 +133,12 @@ var init_session_types = __esm({
         title: z.string().optional(),
         commitHash: z.string().optional(),
         risk: z.string().optional(),
-        realizedRisk: z.string().optional()
+        realizedRisk: z.string().optional(),
+        startedAt: z.string().optional(),
+        completedAt: z.string().optional()
       })).default([]),
+      // T-187: Per-ticket timing -- set when ticket is picked, cleared on commit
+      ticketStartedAt: z.string().nullable().default(null),
       // FINALIZE checkpoint
       finalizeCheckpoint: z.enum(["staged", "staged_override", "precommit_passed", "committed"]).nullable().default(null),
       // Git state
@@ -196,6 +200,10 @@ var init_session_types = __esm({
       lastGuideCall: z.string().optional(),
       startedAt: z.string(),
       guideCallCount: z.number().default(0),
+      // ISS-098: Codex availability cache -- skip codex after failure
+      // ISS-110: Changed from boolean to ISO timestamp with 10-minute TTL
+      codexUnavailable: z.boolean().optional(),
+      codexUnavailableSince: z.string().optional(),
       // Supersession tracking
       supersededBy: z.string().optional(),
       supersededSession: z.string().optional(),
@@ -555,12 +563,13 @@ var init_project_state = __esm({
       totalTicketCount;
       openTicketCount;
       completeTicketCount;
-      openIssueCount;
+      activeIssueCount;
       issuesBySeverity;
       activeNoteCount;
       archivedNoteCount;
       activeLessonCount;
       deprecatedLessonCount;
+      lessonTags;
       constructor(input) {
         this.tickets = input.tickets;
         this.issues = input.issues;
@@ -641,19 +650,19 @@ var init_project_state = __esm({
           lByID.set(l.id, l);
         }
         this.lessonsByID = lByID;
-        this.totalTicketCount = input.tickets.length;
-        this.openTicketCount = input.tickets.filter(
+        this.totalTicketCount = this.leafTickets.length;
+        this.openTicketCount = this.leafTickets.filter(
           (t) => t.status !== "complete"
         ).length;
-        this.completeTicketCount = input.tickets.filter(
+        this.completeTicketCount = this.leafTickets.filter(
           (t) => t.status === "complete"
         ).length;
-        this.openIssueCount = input.issues.filter(
-          (i) => i.status === "open"
+        this.activeIssueCount = input.issues.filter(
+          (i) => i.status !== "resolved"
         ).length;
         const bySev = /* @__PURE__ */ new Map();
         for (const i of input.issues) {
-          if (i.status === "open") {
+          if (i.status !== "resolved") {
             bySev.set(i.severity, (bySev.get(i.severity) ?? 0) + 1);
           }
         }
@@ -670,6 +679,7 @@ var init_project_state = __esm({
         this.deprecatedLessonCount = this.lessons.filter(
           (l) => l.status === "deprecated" || l.status === "superseded"
         ).length;
+        this.lessonTags = [...new Set(this.lessons.flatMap((l) => l.tags ?? []))].sort();
       }
       // --- Query Methods ---
       isUmbrella(ticket) {
@@ -1843,7 +1853,7 @@ function formatStatus(state, format, activeSessions = []) {
     completeTickets: state.completeLeafTicketCount,
     openTickets: state.leafTicketCount - state.completeLeafTicketCount,
     blockedTickets: state.blockedCount,
-    openIssues: state.openIssueCount,
+    openIssues: state.activeIssueCount,
     activeNotes: state.activeNoteCount,
     archivedNotes: state.archivedNoteCount,
     activeLessons: state.activeLessonCount,
@@ -1865,7 +1875,7 @@ function formatStatus(state, format, activeSessions = []) {
     `# ${escapeMarkdownInline(state.config.project)}`,
     "",
     `Tickets: ${state.completeLeafTicketCount}/${state.leafTicketCount} complete, ${state.blockedCount} blocked`,
-    `Issues: ${state.openIssueCount} open`,
+    `Issues: ${state.activeIssueCount} open`,
     `Notes: ${state.activeNoteCount} active, ${state.archivedNoteCount} archived`,
     `Lessons: ${state.activeLessonCount} active, ${state.deprecatedLessonCount} deprecated`,
     `Handovers: ${state.handoverFilenames.length}`,
@@ -2291,7 +2301,7 @@ function formatRecap(recap, state, format) {
     lines.push("No snapshot found. Run `claudestory snapshot` to enable session diffs.");
     lines.push("");
     lines.push(`Tickets: ${state.completeLeafTicketCount}/${state.leafTicketCount} complete, ${state.blockedCount} blocked`);
-    lines.push(`Issues: ${state.openIssueCount} open`);
+    lines.push(`Issues: ${state.activeIssueCount} open`);
   } else {
     lines.push(`# ${escapeMarkdownInline(state.config.project)} \u2014 Recap`);
     lines.push("");
@@ -2299,6 +2309,13 @@ function formatRecap(recap, state, format) {
     if (recap.partial) {
       lines.push("**Note:** Snapshot was taken from a project with integrity warnings. Diff may be incomplete.");
     }
+    if (recap.staleness) {
+      if (recap.staleness.status === "diverged") {
+        lines.push("**Warning:** Snapshot commit is not an ancestor of current HEAD (history diverged; possible rebase, force-push, or branch switch).");
+      } else if (recap.staleness.status === "behind" && recap.staleness.commitsBehind) {
+        lines.push(`**Warning:** Snapshot is ${recap.staleness.commitsBehind} commit(s) behind HEAD -- context may be stale.`);
+      }
+    }
     const changes = recap.changes;
     const hasChanges = hasAnyChanges(changes);
     if (!hasChanges) {
@@ -2560,7 +2577,7 @@ function formatFullExport(state, format) {
   lines.push(`# ${escapeMarkdownInline(state.config.project)} \u2014 Full Export`);
   lines.push("");
   lines.push(`Tickets: ${state.completeLeafTicketCount}/${state.leafTicketCount} complete`);
-  lines.push(`Issues: ${state.openIssueCount} open`);
+  lines.push(`Issues: ${state.activeIssueCount} open`);
   lines.push(`Notes: ${state.activeNoteCount} active, ${state.archivedNoteCount} archived`);
   lines.push(`Lessons: ${state.activeLessonCount} active, ${state.deprecatedLessonCount} deprecated`);
   lines.push("");
@@ -3460,6 +3477,204 @@ var init_issue2 = __esm({
   }
 });
 
+// src/autonomous/git-inspector.ts
+import { execFile } from "child_process";
+async function git(cwd, args, parse) {
+  return new Promise((resolve10) => {
+    execFile("git", args, { cwd, timeout: GIT_TIMEOUT, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        const message = stderr?.trim() || err.message || "unknown git error";
+        resolve10({ ok: false, reason: "git_error", message });
+        return;
+      }
+      try {
+        resolve10({ ok: true, data: parse(stdout) });
+      } catch (parseErr) {
+        resolve10({ ok: false, reason: "parse_error", message: parseErr.message });
+      }
+    });
+  });
+}
+async function gitStatus(cwd) {
+  return git(
+    cwd,
+    ["status", "--porcelain"],
+    (out) => out.split("\n").filter((l) => l.length > 0)
+  );
+}
+async function gitHead(cwd) {
+  const hashResult = await git(cwd, ["rev-parse", "HEAD"], (out) => out.trim());
+  if (!hashResult.ok) return hashResult;
+  const branchResult = await gitBranch(cwd);
+  return {
+    ok: true,
+    data: {
+      hash: hashResult.data,
+      branch: branchResult.ok ? branchResult.data : null
+    }
+  };
+}
+async function gitBranch(cwd) {
+  return git(cwd, ["symbolic-ref", "--short", "HEAD"], (out) => out.trim());
+}
+async function gitMergeBase(cwd, base) {
+  return git(cwd, ["merge-base", "HEAD", base], (out) => out.trim());
+}
+async function gitDiffStat(cwd, base) {
+  return git(cwd, ["diff", "--numstat", base], parseDiffNumstat);
+}
+async function gitDiffNames(cwd, base) {
+  return git(
+    cwd,
+    ["diff", "--name-only", base],
+    (out) => out.split("\n").filter((l) => l.length > 0)
+  );
+}
+async function gitBlobHash(cwd, file) {
+  return git(cwd, ["hash-object", file], (out) => out.trim());
+}
+async function gitDiffCachedNames(cwd) {
+  return git(
+    cwd,
+    ["diff", "--cached", "--name-only"],
+    (out) => out.split("\n").filter((l) => l.length > 0)
+  );
+}
+async function gitStash(cwd, message) {
+  const pushResult = await git(cwd, ["stash", "push", "-m", message], () => void 0);
+  if (!pushResult.ok) return { ok: false, reason: pushResult.reason, message: pushResult.message };
+  const hashResult = await git(cwd, ["rev-parse", "stash@{0}"], (out) => out.trim());
+  if (!hashResult.ok) {
+    const listResult = await git(
+      cwd,
+      ["stash", "list", "--format=%gd %s"],
+      (out) => out.split("\n").filter((l) => l.includes(message))
+    );
+    if (listResult.ok && listResult.data.length > 0) {
+      const ref = listResult.data[0].split(" ")[0];
+      const refHash = await git(cwd, ["rev-parse", ref], (out) => out.trim());
+      if (refHash.ok) return { ok: true, data: refHash.data };
+    }
+    return { ok: false, reason: "stash_hash_failed", message: "Stash created but could not be identified. Run `git stash list` to find and pop it manually." };
+  }
+  return { ok: true, data: hashResult.data };
+}
+async function gitStashPop(cwd, commitHash) {
+  if (!commitHash) {
+    return git(cwd, ["stash", "pop"], () => void 0);
+  }
+  const listResult = await git(
+    cwd,
+    ["stash", "list", "--format=%gd %H"],
+    (out) => out.split("\n").filter((l) => l.length > 0).map((l) => {
+      const [ref, hash] = l.split(" ", 2);
+      return { ref, hash };
+    })
+  );
+  if (!listResult.ok) {
+    return { ok: false, reason: "stash_list_failed", message: `Cannot list stash entries to find ${commitHash}. Run \`git stash list\` and pop manually.` };
+  }
+  const match = listResult.data.find((e) => e.hash === commitHash);
+  if (!match) {
+    return { ok: false, reason: "stash_not_found", message: `No stash entry with commit hash ${commitHash}` };
+  }
+  return git(cwd, ["stash", "pop", match.ref], () => void 0);
+}
+async function gitDiffTreeNames(cwd, commitHash) {
+  return git(
+    cwd,
+    ["diff-tree", "--name-only", "--no-commit-id", "-r", commitHash],
+    (out) => out.split("\n").filter((l) => l.trim().length > 0)
+  );
+}
+async function gitIsAncestor(cwd, ancestor, descendant) {
+  if (!SAFE_REF.test(ancestor) || !SAFE_REF.test(descendant)) {
+    return { ok: false, reason: "git_error", message: "invalid ref format" };
+  }
+  return new Promise((resolve10) => {
+    execFile(
+      "git",
+      ["merge-base", "--is-ancestor", ancestor, descendant],
+      { cwd, timeout: GIT_TIMEOUT },
+      (err) => {
+        if (!err) {
+          resolve10({ ok: true, data: true });
+          return;
+        }
+        const code = err.code;
+        if (code === 1) {
+          resolve10({ ok: true, data: false });
+          return;
+        }
+        resolve10({ ok: false, reason: "git_error", message: err.message });
+      }
+    );
+  });
+}
+async function gitLogRange(cwd, from, to, limit = 20) {
+  if (from && !SAFE_REF.test(from)) {
+    return { ok: false, reason: "invalid_ref", message: `Invalid git ref: ${from}` };
+  }
+  if (to && !SAFE_REF.test(to)) {
+    return { ok: false, reason: "invalid_ref", message: `Invalid git ref: ${to}` };
+  }
+  if (!from || !to) {
+    return { ok: true, data: [] };
+  }
+  return git(
+    cwd,
+    ["log", "--oneline", `-${limit}`, `${from}..${to}`],
+    (out) => out.split("\n").filter((l) => l.trim().length > 0)
+  );
+}
+async function gitHeadHash(cwd) {
+  return new Promise((resolve10) => {
+    execFile("git", ["rev-parse", "HEAD"], { cwd, timeout: 3e3 }, (err, stdout) => {
+      if (err) {
+        const message = err.stderr?.trim() || err.message || "unknown git error";
+        resolve10({ ok: false, reason: "git_error", message });
+        return;
+      }
+      resolve10({ ok: true, data: stdout.trim() });
+    });
+  });
+}
+async function gitCommitDistance(cwd, fromSha, toSha) {
+  if (!SAFE_REF.test(fromSha) || !SAFE_REF.test(toSha)) {
+    return { ok: false, reason: "git_error", message: "invalid ref format" };
+  }
+  return git(cwd, ["rev-list", "--count", `${fromSha}..${toSha}`], (out) => {
+    const n = parseInt(out.trim(), 10);
+    if (Number.isNaN(n)) throw new Error(`unexpected rev-list output: ${out}`);
+    return n;
+  });
+}
+function parseDiffNumstat(out) {
+  const lines = out.split("\n").filter((l) => l.length > 0);
+  let insertions = 0;
+  let deletions = 0;
+  let filesChanged = 0;
+  for (const line of lines) {
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const added = parseInt(parts[0], 10);
+    const removed = parseInt(parts[1], 10);
+    if (!Number.isNaN(added)) insertions += added;
+    if (!Number.isNaN(removed)) deletions += removed;
+    filesChanged++;
+  }
+  return { filesChanged, insertions, deletions, totalLines: insertions + deletions };
+}
+var GIT_TIMEOUT, SAFE_REF;
+var init_git_inspector = __esm({
+  "src/autonomous/git-inspector.ts"() {
+    "use strict";
+    init_esm_shims();
+    GIT_TIMEOUT = 1e4;
+    SAFE_REF = /^[0-9a-f]{4,40}$/i;
+  }
+});
+
 // src/core/snapshot.ts
 var snapshot_exports = {};
 __export(snapshot_exports, {
@@ -3499,6 +3714,10 @@ async function saveSnapshot(root, loadResult) {
       }))
     } : {}
   };
+  const headResult = await gitHeadHash(absRoot);
+  if (headResult.ok) {
+    snapshot.gitHead = headResult.data;
+  }
   const json = JSON.stringify(snapshot, null, 2) + "\n";
   const targetPath = join11(snapshotsDir, filename);
   const wrapDir = join11(absRoot, ".story");
@@ -3694,7 +3913,7 @@ function diffStates(snapshotState, currentState) {
     handovers: { added: handoversAdded, removed: handoversRemoved }
   };
 }
-function buildRecap(currentState, snapshotInfo) {
+async function buildRecap(currentState, snapshotInfo, root) {
   const next = nextTicket(currentState);
   const nextTicketAction = next.kind === "found" ? { id: next.ticket.id, title: next.ticket.title, phase: next.ticket.phase } : null;
   const highSeverityIssues = currentState.issues.filter(
@@ -3724,6 +3943,30 @@ function buildRecap(currentState, snapshotInfo) {
   });
   const changes = diffStates(snapshotState, currentState);
   const recentlyClearedBlockers = changes.blockers.cleared;
+  let staleness;
+  if (snapshot.gitHead) {
+    const currentHeadResult = await gitHeadHash(root);
+    if (currentHeadResult.ok) {
+      const snapshotSha = snapshot.gitHead;
+      const currentSha = currentHeadResult.data;
+      if (snapshotSha !== currentSha) {
+        const ancestorResult = await gitIsAncestor(root, snapshotSha, currentSha);
+        if (ancestorResult.ok && ancestorResult.data) {
+          const distResult = await gitCommitDistance(root, snapshotSha, currentSha);
+          if (distResult.ok) {
+            staleness = {
+              status: "behind",
+              snapshotSha,
+              currentSha,
+              commitsBehind: distResult.data
+            };
+          }
+        } else if (ancestorResult.ok && !ancestorResult.data) {
+          staleness = { status: "diverged", snapshotSha, currentSha };
+        }
+      }
+    }
+  }
   return {
     snapshot: { filename, createdAt: snapshot.createdAt },
     changes,
@@ -3732,7 +3975,8 @@ function buildRecap(currentState, snapshotInfo) {
       highSeverityIssues,
       recentlyClearedBlockers
     },
-    partial: (snapshot.warnings ?? []).length > 0
+    partial: (snapshot.warnings ?? []).length > 0,
+    ...staleness ? { staleness } : {}
   };
 }
 function formatSnapshotFilename(date) {
@@ -3779,6 +4023,7 @@ var init_snapshot = __esm({
     init_project_state();
     init_queries();
     init_project_loader();
+    init_git_inspector();
     LoadWarningSchema = z9.object({
       type: z9.string(),
       file: z9.string(),
@@ -3795,7 +4040,8 @@ var init_snapshot = __esm({
       notes: z9.array(NoteSchema).optional().default([]),
       lessons: z9.array(LessonSchema).optional().default([]),
       handoverFilenames: z9.array(z9.string()).optional().default([]),
-      warnings: z9.array(LoadWarningSchema).optional()
+      warnings: z9.array(LoadWarningSchema).optional(),
+      gitHead: z9.string().optional()
     });
     MAX_SNAPSHOTS = 20;
   }
@@ -4172,9 +4418,9 @@ var init_session = __esm({
 
 // src/mcp/index.ts
 init_esm_shims();
-import { realpathSync as realpathSync3, existsSync as existsSync13 } from "fs";
-import { resolve as resolve9, join as join24, isAbsolute } from "path";
-import { z as z11 } from "zod";
+import { realpathSync as realpathSync3, existsSync as existsSync14 } from "fs";
+import { resolve as resolve9, join as join26, isAbsolute } from "path";
+import { z as z12 } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -4223,7 +4469,8 @@ function checkRoot(candidate) {
 init_esm_shims();
 init_session_types();
 import { z as z10 } from "zod";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
+import { join as join23 } from "path";
 
 // src/autonomous/review-lenses/mcp-handlers.ts
 init_esm_shims();
@@ -5593,6 +5840,9 @@ function validateFindings(raw, lensName) {
       continue;
     }
     const normalized = normalizeFields(item);
+    if (typeof normalized.lens !== "string" && typeof lensName === "string") {
+      normalized.lens = lensName;
+    }
     const reason = checkFinding(normalized, lensName);
     if (reason) {
       invalid.push({ raw: item, reason });
@@ -6318,6 +6568,58 @@ function redactArtifactSecrets(artifact, redactedLines) {
   return lines.map((line, i) => linesToRedact.has(i) ? "[REDACTED -- potential secret]" : line).join("\n");
 }
 
+// src/autonomous/review-lenses/diff-scope.ts
+init_esm_shims();
+function parseDiffScope(diff) {
+  const changedFiles = /* @__PURE__ */ new Set();
+  const addedLines = /* @__PURE__ */ new Map();
+  if (!diff) return { changedFiles, addedLines };
+  const lines = diff.split("\n");
+  let currentFile = null;
+  let currentLineNum = 0;
+  for (const line of lines) {
+    if (line.startsWith("+++ ")) {
+      if (line.startsWith("+++ /dev/null")) {
+        currentFile = null;
+        continue;
+      }
+      const rawPath = line.startsWith("+++ b/") ? line.slice(6) : line.slice(4);
+      currentFile = normalizePath(rawPath);
+      changedFiles.add(currentFile);
+      if (!addedLines.has(currentFile)) {
+        addedLines.set(currentFile, /* @__PURE__ */ new Set());
+      }
+      currentLineNum = 0;
+      continue;
+    }
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
+    if (hunkMatch) {
+      currentLineNum = parseInt(hunkMatch[1], 10) - 1;
+      continue;
+    }
+    if (!currentFile) continue;
+    if (line.startsWith("-")) continue;
+    currentLineNum++;
+    if (line.startsWith("+")) {
+      addedLines.get(currentFile).add(currentLineNum);
+    }
+  }
+  return { changedFiles, addedLines };
+}
+function normalizePath(p) {
+  return p.startsWith("./") ? p.slice(2) : p;
+}
+function classifyOrigin(finding, scope, stage) {
+  if (stage === "PLAN_REVIEW") return "introduced";
+  if (!finding.file) return "introduced";
+  const file = normalizePath(finding.file);
+  if (!scope.changedFiles.has(file)) return "pre-existing";
+  if (finding.line == null) return "introduced";
+  const fileLines = scope.addedLines.get(file);
+  if (!fileLines || !fileLines.has(finding.line)) return "pre-existing";
+  return "introduced";
+}
+
 // src/autonomous/review-lenses/mcp-handlers.ts
 var MAX_PROMPT_SIZE = 1e4;
 function handlePrepare(input) {
@@ -6415,6 +6717,7 @@ function handleSynthesize(input) {
     }
   }
   const stage = input.stage ?? "CODE_REVIEW";
+  const diffScope = input.diff && input.changedFiles && stage === "CODE_REVIEW" ? parseDiffScope(input.diff) : null;
   const lensesCompleted = [];
   const lensesFailed = [];
   const lensesInsufficientContext = [];
@@ -6447,7 +6750,8 @@ function handleSynthesize(input) {
         const enriched = {
           ...f,
           issueKey: generateIssueKey(f),
-          blocking: computeBlocking(f, stage, policy)
+          blocking: computeBlocking(f, stage, policy),
+          origin: diffScope ? classifyOrigin(f, diffScope, stage) : void 0
         };
         allFindings.push(enriched);
       }
@@ -6462,6 +6766,9 @@ function handleSynthesize(input) {
       lensesFailed.push(lens);
     }
   }
+  const preExistingFindings = allFindings.filter(
+    (f) => f.origin === "pre-existing" && f.severity !== "suggestion"
+  );
   const lensMetadata = buildLensMetadata(lensesCompleted, lensesFailed, lensesInsufficientContext);
   const mergerPrompt = buildMergerPrompt(allFindings, lensMetadata, stage);
   return {
@@ -6471,7 +6778,9 @@ function handleSynthesize(input) {
     lensesFailed,
     lensesInsufficientContext,
     droppedFindings: droppedTotal,
-    droppedDetails: dropReasons.slice(0, 5)
+    droppedDetails: dropReasons.slice(0, 5),
+    preExistingFindings,
+    preExistingCount: preExistingFindings.length
   };
 }
 function handleJudge(input) {
@@ -6496,8 +6805,8 @@ function handleJudge(input) {
     [...input.lensesSkipped]
   );
   if (input.convergenceHistory && input.convergenceHistory.length > 0) {
-    const sanitize = (s) => s.replace(/[|\n\r#>`*_~\[\]]/g, " ").slice(0, 50);
-    const historyTable = input.convergenceHistory.map((h) => `| R${h.round} | ${sanitize(h.verdict)} | ${h.blocking} | ${h.important} | ${sanitize(h.newCode)} |`).join("\n");
+    const sanitize2 = (s) => s.replace(/[|\n\r#>`*_~\[\]]/g, " ").slice(0, 50);
+    const historyTable = input.convergenceHistory.map((h) => `| R${h.round} | ${sanitize2(h.verdict)} | ${h.blocking} | ${h.important} | ${sanitize2(h.newCode)} |`).join("\n");
     judgePrompt += `
 
 ## Convergence History
@@ -6846,7 +7155,7 @@ init_output_formatter();
 init_snapshot();
 async function handleRecap(ctx) {
   const snapshotInfo = await loadLatestSnapshot(ctx.root);
-  const recap = buildRecap(ctx.state, snapshotInfo);
+  const recap = await buildRecap(ctx.state, snapshotInfo, ctx.root);
   return { output: formatRecap(recap, ctx.state, ctx.format) };
 }
 
@@ -7814,8 +8123,8 @@ init_handover();
 init_esm_shims();
 init_session_types();
 init_session();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, readdirSync as readdirSync4 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, readdirSync as readdirSync4 } from "fs";
+import { join as join20 } from "path";
 
 // src/autonomous/state-machine.ts
 init_esm_shims();
@@ -7835,15 +8144,17 @@ var TRANSITIONS = {
   // advance → IMPLEMENT, retry stays, exhaustion → PLAN, no-op → COMPLETE (ISS-069)
   TEST: ["CODE_REVIEW", "IMPLEMENT", "TEST"],
   // pass → CODE_REVIEW, fail → IMPLEMENT, retry
-  CODE_REVIEW: ["VERIFY", "FINALIZE", "IMPLEMENT", "PLAN", "CODE_REVIEW", "SESSION_END"],
-  // approve → VERIFY/FINALIZE, reject → IMPLEMENT/PLAN, stay for next round; SESSION_END for tiered exit
-  VERIFY: ["FINALIZE", "IMPLEMENT", "VERIFY"],
+  CODE_REVIEW: ["VERIFY", "BUILD", "FINALIZE", "IMPLEMENT", "PLAN", "CODE_REVIEW", "SESSION_END", "ISSUE_FIX"],
+  // approve → VERIFY/BUILD/FINALIZE, reject → IMPLEMENT/PLAN, stay for next round; SESSION_END for tiered exit; T-208: ISSUE_FIX for issue-fix reviews
+  VERIFY: ["BUILD", "FINALIZE", "IMPLEMENT", "VERIFY"],
+  // pass → BUILD/FINALIZE, fail → IMPLEMENT, retry
+  BUILD: ["FINALIZE", "IMPLEMENT", "BUILD"],
   // pass → FINALIZE, fail → IMPLEMENT, retry
   FINALIZE: ["COMPLETE", "PICK_TICKET"],
   // ISS-084: issues now route through COMPLETE too; PICK_TICKET kept for in-flight session compat
   COMPLETE: ["PICK_TICKET", "HANDOVER", "ISSUE_SWEEP", "SESSION_END"],
-  ISSUE_FIX: ["FINALIZE", "PICK_TICKET", "ISSUE_FIX"],
-  // T-153: fix done → FINALIZE, cancel → PICK_TICKET, retry self
+  ISSUE_FIX: ["FINALIZE", "PICK_TICKET", "ISSUE_FIX", "CODE_REVIEW"],
+  // T-153: fix done → FINALIZE, cancel → PICK_TICKET, retry self; T-208: optional code review
   LESSON_CAPTURE: ["ISSUE_SWEEP", "HANDOVER", "LESSON_CAPTURE"],
   // advance → ISSUE_SWEEP, retry self, done → HANDOVER
   ISSUE_SWEEP: ["ISSUE_SWEEP", "HANDOVER", "PICK_TICKET"],
@@ -7933,189 +8244,55 @@ function requiredRounds(risk) {
       return 3;
   }
 }
-function nextReviewer(previousRounds, backends) {
-  if (backends.length === 0) return "agent";
-  if (backends.length === 1) return backends[0];
-  if (previousRounds.length === 0) return backends[0];
+var CODEX_CACHE_TTL_MS = 10 * 60 * 1e3;
+function isCodexUnavailable(codexUnavailableSince) {
+  if (!codexUnavailableSince) return false;
+  const since = new Date(codexUnavailableSince).getTime();
+  if (Number.isNaN(since)) return false;
+  return Date.now() - since < CODEX_CACHE_TTL_MS;
+}
+function nextReviewer(previousRounds, backends, codexUnavailable, codexUnavailableSince) {
+  const unavailable = codexUnavailableSince ? isCodexUnavailable(codexUnavailableSince) : !!codexUnavailable;
+  const effective = unavailable ? backends.filter((b) => b !== "codex") : backends;
+  if (effective.length === 0) return "agent";
+  if (effective.length === 1) return effective[0];
+  if (previousRounds.length === 0) return effective[0];
   const lastReviewer = previousRounds[previousRounds.length - 1].reviewer;
-  const lastIndex = backends.indexOf(lastReviewer);
-  if (lastIndex === -1) return backends[0];
-  return backends[(lastIndex + 1) % backends.length];
+  const lastIndex = effective.indexOf(lastReviewer);
+  if (lastIndex === -1) return effective[0];
+  return effective[(lastIndex + 1) % effective.length];
 }
 
-// src/autonomous/git-inspector.ts
+// src/autonomous/guide.ts
+init_git_inspector();
+
+// src/autonomous/recipes/loader.ts
 init_esm_shims();
-import { execFile } from "child_process";
-var GIT_TIMEOUT = 1e4;
-async function git(cwd, args, parse) {
-  return new Promise((resolve10) => {
-    execFile("git", args, { cwd, timeout: GIT_TIMEOUT, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
-      if (err) {
-        const message = stderr?.trim() || err.message || "unknown git error";
-        resolve10({ ok: false, reason: "git_error", message });
-        return;
-      }
-      try {
-        resolve10({ ok: true, data: parse(stdout) });
-      } catch (parseErr) {
-        resolve10({ ok: false, reason: "parse_error", message: parseErr.message });
-      }
-    });
-  });
-}
-async function gitStatus(cwd) {
-  return git(
-    cwd,
-    ["status", "--porcelain"],
-    (out) => out.split("\n").filter((l) => l.length > 0)
-  );
-}
-async function gitHead(cwd) {
-  const hashResult = await git(cwd, ["rev-parse", "HEAD"], (out) => out.trim());
-  if (!hashResult.ok) return hashResult;
-  const branchResult = await gitBranch(cwd);
-  return {
-    ok: true,
-    data: {
-      hash: hashResult.data,
-      branch: branchResult.ok ? branchResult.data : null
-    }
-  };
-}
-async function gitBranch(cwd) {
-  return git(cwd, ["symbolic-ref", "--short", "HEAD"], (out) => out.trim());
-}
-async function gitMergeBase(cwd, base) {
-  return git(cwd, ["merge-base", "HEAD", base], (out) => out.trim());
-}
-async function gitDiffStat(cwd, base) {
-  return git(cwd, ["diff", "--numstat", base], parseDiffNumstat);
-}
-async function gitDiffNames(cwd, base) {
-  return git(
-    cwd,
-    ["diff", "--name-only", base],
-    (out) => out.split("\n").filter((l) => l.length > 0)
-  );
-}
-async function gitBlobHash(cwd, file) {
-  return git(cwd, ["hash-object", file], (out) => out.trim());
-}
-async function gitDiffCachedNames(cwd) {
-  return git(
-    cwd,
-    ["diff", "--cached", "--name-only"],
-    (out) => out.split("\n").filter((l) => l.length > 0)
-  );
-}
-async function gitStash(cwd, message) {
-  const pushResult = await git(cwd, ["stash", "push", "-m", message], () => void 0);
-  if (!pushResult.ok) return { ok: false, reason: pushResult.reason, message: pushResult.message };
-  const hashResult = await git(cwd, ["rev-parse", "stash@{0}"], (out) => out.trim());
-  if (!hashResult.ok) {
-    const listResult = await git(
-      cwd,
-      ["stash", "list", "--format=%gd %s"],
-      (out) => out.split("\n").filter((l) => l.includes(message))
-    );
-    if (listResult.ok && listResult.data.length > 0) {
-      const ref = listResult.data[0].split(" ")[0];
-      const refHash = await git(cwd, ["rev-parse", ref], (out) => out.trim());
-      if (refHash.ok) return { ok: true, data: refHash.data };
-    }
-    return { ok: false, reason: "stash_hash_failed", message: "Stash created but could not be identified. Run `git stash list` to find and pop it manually." };
-  }
-  return { ok: true, data: hashResult.data };
-}
-async function gitStashPop(cwd, commitHash) {
-  if (!commitHash) {
-    return git(cwd, ["stash", "pop"], () => void 0);
-  }
-  const listResult = await git(
-    cwd,
-    ["stash", "list", "--format=%gd %H"],
-    (out) => out.split("\n").filter((l) => l.length > 0).map((l) => {
-      const [ref, hash] = l.split(" ", 2);
-      return { ref, hash };
-    })
-  );
-  if (!listResult.ok) {
-    return { ok: false, reason: "stash_list_failed", message: `Cannot list stash entries to find ${commitHash}. Run \`git stash list\` and pop manually.` };
-  }
-  const match = listResult.data.find((e) => e.hash === commitHash);
-  if (!match) {
-    return { ok: false, reason: "stash_not_found", message: `No stash entry with commit hash ${commitHash}` };
-  }
-  return git(cwd, ["stash", "pop", match.ref], () => void 0);
-}
-async function gitDiffTreeNames(cwd, commitHash) {
-  return git(
-    cwd,
-    ["diff-tree", "--name-only", "--no-commit-id", "-r", commitHash],
-    (out) => out.split("\n").filter((l) => l.trim().length > 0)
-  );
-}
-var SAFE_REF = /^[0-9a-f]{4,40}$/i;
-async function gitLogRange(cwd, from, to, limit = 20) {
-  if (from && !SAFE_REF.test(from)) {
-    return { ok: false, reason: "invalid_ref", message: `Invalid git ref: ${from}` };
-  }
-  if (to && !SAFE_REF.test(to)) {
-    return { ok: false, reason: "invalid_ref", message: `Invalid git ref: ${to}` };
-  }
-  if (!from || !to) {
-    return { ok: true, data: [] };
-  }
-  return git(
-    cwd,
-    ["log", "--oneline", `-${limit}`, `${from}..${to}`],
-    (out) => out.split("\n").filter((l) => l.trim().length > 0)
-  );
-}
-function parseDiffNumstat(out) {
-  const lines = out.split("\n").filter((l) => l.length > 0);
-  let insertions = 0;
-  let deletions = 0;
-  let filesChanged = 0;
-  for (const line of lines) {
-    const parts = line.split("	");
-    if (parts.length < 3) continue;
-    const added = parseInt(parts[0], 10);
-    const removed = parseInt(parts[1], 10);
-    if (!Number.isNaN(added)) insertions += added;
-    if (!Number.isNaN(removed)) deletions += removed;
-    filesChanged++;
-  }
-  return { filesChanged, insertions, deletions, totalLines: insertions + deletions };
-}
-
-// src/autonomous/recipes/loader.ts
-init_esm_shims();
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join14, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var DEFAULT_PIPELINE = [
-  "PICK_TICKET",
-  "PLAN",
-  "PLAN_REVIEW",
-  "IMPLEMENT",
-  "CODE_REVIEW",
-  "FINALIZE",
-  "COMPLETE"
-];
-var DEFAULT_DEFAULTS = {
-  maxTicketsPerSession: 3,
-  compactThreshold: "high",
-  reviewBackends: ["codex", "agent"]
-};
-function loadRecipe(recipeName) {
-  if (!/^[A-Za-z0-9_-]+$/.test(recipeName)) {
-    throw new Error(`Invalid recipe name: ${recipeName}`);
-  }
-  const recipesDir = join14(dirname3(fileURLToPath2(import.meta.url)), "..", "recipes");
-  const path2 = join14(recipesDir, `${recipeName}.json`);
-  const raw = readFileSync7(path2, "utf-8");
-  return JSON.parse(raw);
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join14, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var DEFAULT_PIPELINE = [
+  "PICK_TICKET",
+  "PLAN",
+  "PLAN_REVIEW",
+  "IMPLEMENT",
+  "CODE_REVIEW",
+  "FINALIZE",
+  "COMPLETE"
+];
+var DEFAULT_DEFAULTS = {
+  maxTicketsPerSession: 3,
+  compactThreshold: "high",
+  reviewBackends: ["codex", "agent"]
+};
+function loadRecipe(recipeName) {
+  if (!/^[A-Za-z0-9_-]+$/.test(recipeName)) {
+    throw new Error(`Invalid recipe name: ${recipeName}`);
+  }
+  const recipesDir = join14(dirname3(fileURLToPath2(import.meta.url)), "..", "recipes");
+  const path2 = join14(recipesDir, `${recipeName}.json`);
+  const raw = readFileSync7(path2, "utf-8");
+  return JSON.parse(raw);
 }
 function resolveRecipe(recipeName, projectOverrides) {
   let raw;
@@ -8169,6 +8346,13 @@ function resolveRecipe(recipeName, projectOverrides) {
       pipeline.splice(implementIdx + 1, 0, "TEST");
     }
   }
+  if (stages2.ISSUE_FIX?.enableCodeReview) {
+    if (pipeline.includes("VERIFY") || pipeline.includes("BUILD")) {
+      throw new Error(
+        "ISSUE_FIX.enableCodeReview is incompatible with VERIFY/BUILD in the pipeline (issue fixes use goto transitions, not pipeline walker)"
+      );
+    }
+  }
   const postComplete = raw.postComplete ? [...raw.postComplete] : [];
   const recipeDefaults = raw.defaults ?? {};
   const defaults = {
@@ -8466,7 +8650,15 @@ function buildTargetedStuckHandover(candidatesText, sessionId) {
 var PickTicketStage = class {
   id = "PICK_TICKET";
   async enter(ctx) {
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch (err) {
+      return {
+        action: "retry",
+        instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Check .story/ files for corruption, then call autonomous_guide with action "report" again.`
+      };
+    }
     if (isTargetedMode(ctx.state)) {
       const remaining = getRemainingTargets(ctx.state);
       if (remaining.length === 0) {
@@ -8566,7 +8758,12 @@ var PickTicketStage = class {
     }
     const targetReject = this.enforceTargetList(ctx, ticketId);
     if (targetReject) return targetReject;
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch (err) {
+      return { action: "retry", instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Check .story/ files for corruption.` };
+    }
     const ticket = projectState.ticketByID(ticketId);
     if (!ticket) {
       return { action: "retry", instruction: `Ticket ${ticketId} not found. Pick a valid ticket.` };
@@ -8588,7 +8785,8 @@ var PickTicketStage = class {
     ctx.updateDraft({
       ticket: { id: ticket.id, title: ticket.title, claimed: true },
       reviews: { plan: [], code: [] },
-      finalizeCheckpoint: null
+      finalizeCheckpoint: null,
+      ticketStartedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     return {
       action: "advance",
@@ -8619,7 +8817,12 @@ ${ticket.description}` : "",
   async handleIssuePick(ctx, issueId) {
     const targetReject = this.enforceTargetList(ctx, issueId);
     if (targetReject) return targetReject;
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch (err) {
+      return { action: "retry", instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Check .story/ files for corruption.` };
+    }
     const issue = projectState.issues.find((i) => i.id === issueId);
     if (!issue) {
       return { action: "retry", instruction: `Issue ${issueId} not found. Pick a valid issue or ticket.` };
@@ -8628,11 +8831,16 @@ ${ticket.description}` : "",
     if (issue.status !== "open" && !(targeted && issue.status === "inprogress")) {
       return { action: "retry", instruction: `Issue ${issueId} is ${issue.status}. Pick an open issue.` };
     }
+    const transitionId = `issue-pick-${issueId}-${Date.now()}`;
+    ctx.writeState({
+      pendingProjectMutation: { type: "issue_update", target: issueId, field: "status", value: "inprogress", expectedCurrent: issue.status, transitionId }
+    });
     try {
       const { handleIssueUpdate: handleIssueUpdate2 } = await Promise.resolve().then(() => (init_issue2(), issue_exports));
-      await handleIssueUpdate2({ id: issueId, status: "inprogress" }, "json", ctx.root);
+      await handleIssueUpdate2(issueId, { status: "inprogress" }, "json", ctx.root);
     } catch {
     }
+    ctx.writeState({ pendingProjectMutation: null });
     ctx.updateDraft({
       currentIssue: { id: issue.id, title: issue.title, severity: issue.severity },
       ticket: void 0,
@@ -8773,7 +8981,7 @@ var PlanReviewStage = class {
     const backends = ctx.state.config.reviewBackends;
     const existingReviews = ctx.state.reviews.plan;
     const roundNum = existingReviews.length + 1;
-    const reviewer = nextReviewer(existingReviews, backends);
+    const reviewer = nextReviewer(existingReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
     const risk = ctx.state.ticket?.risk ?? "low";
     const minRounds = requiredRounds(risk);
     if (reviewer === "lenses") {
@@ -8784,10 +8992,11 @@ var PlanReviewStage = class {
           "This round uses the **multi-lens review orchestrator** for plan review. It fans out to specialized review agents (Clean Code, Security, Error Handling, and more) in parallel to evaluate the plan from multiple perspectives.",
           "",
           "1. Read the plan file",
-          "2. Call `prepareLensReview()` with the plan text (stage: PLAN_REVIEW)",
-          "3. Spawn all lens subagents in parallel",
-          "4. Collect results and pass through the merger and judge pipeline",
-          "5. Report the final SynthesisResult verdict and findings",
+          "2. Call `claudestory_review_lenses_prepare` with the plan text as diff, stage: PLAN_REVIEW, and ticketDescription",
+          "3. Spawn all lens subagents in parallel (each prompt is returned by the prepare tool)",
+          "4. Collect results and call `claudestory_review_lenses_synthesize` with the lens results",
+          "5. Run the merger agent with the returned mergerPrompt, then call `claudestory_review_lenses_judge`",
+          "6. Run the judge agent and report the final SynthesisResult verdict and findings",
           "",
           "When done, call `claudestory_autonomous_guide` with:",
           "```json",
@@ -8814,7 +9023,11 @@ var PlanReviewStage = class {
         `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "plan_review_round", "verdict": "<approve|revise|request_changes|reject>", "findings": [...] } }`,
         "```"
       ].join("\n"),
-      reminders: ["Report the exact verdict and findings from the reviewer."],
+      reminders: [
+        "Report the exact verdict and findings from the reviewer.",
+        "IMPORTANT: After the review, file ANY pre-existing issues discovered using claudestory_issue_create with severity and impact. Do NOT skip this step.",
+        ...reviewer === "codex" ? ["If codex is unavailable (usage limit, error, etc.), fall back to agent review and include 'codex unavailable' in your report notes."] : []
+      ],
       transitionedFrom: ctx.state.previousState ?? void 0
     };
   }
@@ -8827,7 +9040,8 @@ var PlanReviewStage = class {
     const roundNum = planReviews.length + 1;
     const findings = report.findings ?? [];
     const backends = ctx.state.config.reviewBackends;
-    const reviewerBackend = nextReviewer(planReviews, backends);
+    const computedReviewer = nextReviewer(planReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
+    const reviewerBackend = report.reviewer ?? (computedReviewer === "codex" && report.notes && /codex\b.*\b(unavail|limit|failed|down|error|usage)/i.test(report.notes) ? "agent" : null) ?? computedReviewer;
     planReviews.push({
       round: roundNum,
       reviewer: reviewerBackend,
@@ -8839,6 +9053,9 @@ var PlanReviewStage = class {
       codexSessionId: report.reviewerSessionId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    if (report.notes && /codex\b.*\b(unavail|limit|failed|down|error|usage)/i.test(report.notes)) {
+      ctx.writeState({ codexUnavailable: true, codexUnavailableSince: (/* @__PURE__ */ new Date()).toISOString() });
+    }
     const risk = ctx.state.ticket?.risk ?? "low";
     const minRounds = requiredRounds(risk);
     const hasCriticalOrMajor = findings.some(
@@ -8926,7 +9143,7 @@ var PlanReviewStage = class {
       }
       return { action: "advance" };
     }
-    const nextReviewerName = nextReviewer(planReviews, backends);
+    const nextReviewerName = nextReviewer(planReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
     return {
       action: "retry",
       instruction: [
@@ -8943,6 +9160,7 @@ var PlanReviewStage = class {
 
 // src/autonomous/stages/implement.ts
 init_esm_shims();
+init_git_inspector();
 var ImplementStage = class {
   id = "IMPLEMENT";
   async enter(ctx) {
@@ -9048,7 +9266,7 @@ var WriteTestsStage = class {
     const exitMatch = notes.match(EXIT_CODE_REGEX);
     const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : -1;
     const failMatch = notes.match(FAIL_COUNT_REGEX);
-    const currentFailCount = failMatch ? parseInt(failMatch[1], 10) : -1;
+    const currentFailCount = failMatch ? parseInt(failMatch[1], 10) : exitCode === 0 ? 0 : -1;
     const baseline = ctx.state.testBaseline;
     const baselineFailCount = baseline?.failCount ?? -1;
     const nextRetry = retryCount + 1;
@@ -9224,26 +9442,29 @@ var CodeReviewStage = class {
     const backends = ctx.state.config.reviewBackends;
     const codeReviews = ctx.state.reviews.code;
     const roundNum = codeReviews.length + 1;
-    const reviewer = nextReviewer(codeReviews, backends);
+    const reviewer = nextReviewer(codeReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
     const risk = ctx.state.ticket?.realizedRisk ?? ctx.state.ticket?.risk ?? "low";
     const rounds = requiredRounds(risk);
     const mergeBase = ctx.state.git.mergeBase;
+    const isIssueFix = !!ctx.state.currentIssue;
+    const issueHeader = isIssueFix ? `Issue Fix Code Review (${ctx.state.currentIssue.id})` : "Code Review";
     const diffCommand = mergeBase ? `\`git diff ${mergeBase}\`` : `\`git diff HEAD\` AND \`git ls-files --others --exclude-standard\``;
     const diffReminder = mergeBase ? `Run: git diff ${mergeBase} \u2014 pass FULL output to reviewer.` : "Run: git diff HEAD + git ls-files --others --exclude-standard \u2014 pass FULL output to reviewer.";
     if (reviewer === "lenses") {
       return {
         instruction: [
-          `# Multi-Lens Code Review \u2014 Round ${roundNum} of ${rounds} minimum`,
+          `# Multi-Lens ${issueHeader} \u2014 Round ${roundNum} of ${rounds} minimum`,
           "",
           `Capture the diff with: ${diffCommand}`,
           "",
           "This round uses the **multi-lens review orchestrator**. It fans out to specialized review agents (Clean Code, Security, Error Handling, and more) in parallel, then synthesizes findings into a single verdict.",
           "",
-          "1. Capture the full diff",
-          "2. Call `prepareLensReview()` with the diff and changed file list",
-          "3. Spawn all lens subagents in parallel (each prompt is provided by the orchestrator)",
-          "4. Collect results and pass through the merger and judge pipeline",
-          "5. Report the final SynthesisResult verdict and findings",
+          "1. Capture the full diff and changed file list (`git diff --name-only`)",
+          "2. Call `claudestory_review_lenses_prepare` with the diff, changedFiles, stage: CODE_REVIEW, and ticketDescription",
+          "3. Spawn all lens subagents in parallel (each prompt is returned by the prepare tool)",
+          "4. Collect results and call `claudestory_review_lenses_synthesize` with the lens results, plus the diff and changedFiles from step 1 and the sessionId (enables automatic origin classification and issue filing for pre-existing findings)",
+          "5. Run the merger agent with the returned mergerPrompt, then call `claudestory_review_lenses_judge`",
+          "6. Run the judge agent and report the final SynthesisResult verdict and findings",
           "",
           "When done, report verdict and findings."
         ].join("\n"),
@@ -9251,14 +9472,14 @@ var CodeReviewStage = class {
           diffReminder,
           "Do NOT compress or summarize the diff.",
           "Lens subagents run in parallel with read-only tools (Read, Grep, Glob).",
-          "If the reviewer flags pre-existing issues unrelated to your changes, file them as issues using claudestory_issue_create with severity and impact. Do not fix them in this ticket."
+          "Pre-existing issues in surrounding code are automatically classified and filed by the synthesize tool when you pass diff, changedFiles, and sessionId. Check filedIssues in the synthesize response."
         ],
         transitionedFrom: ctx.state.previousState ?? void 0
       };
     }
     return {
       instruction: [
-        `# Code Review \u2014 Round ${roundNum} of ${rounds} minimum`,
+        `# ${issueHeader} \u2014 Round ${roundNum} of ${rounds} minimum`,
         "",
         `Capture the diff with: ${diffCommand}`,
         "",
@@ -9270,7 +9491,8 @@ var CodeReviewStage = class {
       reminders: [
         diffReminder,
         "Do NOT compress or summarize the diff.",
-        "If the reviewer flags pre-existing issues unrelated to your changes, file them as issues using claudestory_issue_create with severity and impact. Do not fix them in this ticket."
+        "If the reviewer flags pre-existing issues unrelated to your changes, file them as issues using claudestory_issue_create with severity and impact. Do not fix them in this ticket.",
+        ...reviewer === "codex" ? ["If codex is unavailable (usage limit, error, etc.), fall back to agent review and include 'codex unavailable' in your report notes."] : []
       ],
       transitionedFrom: ctx.state.previousState ?? void 0
     };
@@ -9284,7 +9506,8 @@ var CodeReviewStage = class {
     const roundNum = codeReviews.length + 1;
     const findings = report.findings ?? [];
     const backends = ctx.state.config.reviewBackends;
-    const reviewerBackend = nextReviewer(codeReviews, backends);
+    const computedReviewer = nextReviewer(codeReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
+    const reviewerBackend = report.reviewer ?? (computedReviewer === "codex" && report.notes && /codex\b.*\b(unavail|limit|failed|down|error|usage)/i.test(report.notes) ? "agent" : null) ?? computedReviewer;
     codeReviews.push({
       round: roundNum,
       reviewer: reviewerBackend,
@@ -9296,6 +9519,9 @@ var CodeReviewStage = class {
       codexSessionId: report.reviewerSessionId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    if (report.notes && /codex\b.*\b(unavail|limit|failed|down|error|usage)/i.test(report.notes)) {
+      ctx.writeState({ codexUnavailable: true, codexUnavailableSince: (/* @__PURE__ */ new Date()).toISOString() });
+    }
     const risk = ctx.state.ticket?.realizedRisk ?? ctx.state.ticket?.risk ?? "low";
     const minRounds = requiredRounds(risk);
     const hasCriticalOrMajor = findings.some(
@@ -9320,6 +9546,7 @@ var CodeReviewStage = class {
     } else {
       nextAction = "CODE_REVIEW";
     }
+    const isIssueFix = !!ctx.state.currentIssue;
     if (nextAction === "PLAN") {
       clearCache(ctx.dir);
       ctx.writeState({
@@ -9331,9 +9558,12 @@ var CodeReviewStage = class {
         round: roundNum,
         verdict,
         findingCount: findings.length,
-        redirectedTo: "PLAN"
+        redirectedTo: isIssueFix ? "ISSUE_FIX" : "PLAN"
       });
       await ctx.fileDeferredFindings(findings, "code");
+      if (isIssueFix) {
+        return { action: "goto", target: "ISSUE_FIX" };
+      }
       return { action: "back", target: "PLAN", reason: "plan_redirect" };
     }
     const stateUpdate = {
@@ -9356,6 +9586,9 @@ var CodeReviewStage = class {
     });
     await ctx.fileDeferredFindings(findings, "code");
     if (nextAction === "IMPLEMENT") {
+      if (isIssueFix) {
+        return { action: "goto", target: "ISSUE_FIX" };
+      }
       return { action: "back", target: "IMPLEMENT", reason: "request_changes" };
     }
     if (nextAction === "FINALIZE") {
@@ -9382,7 +9615,7 @@ var CodeReviewStage = class {
       }
       return { action: "advance" };
     }
-    const nextReviewerName = nextReviewer(codeReviews, backends);
+    const nextReviewerName = nextReviewer(codeReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
     const mergeBase = ctx.state.git.mergeBase;
     return {
       action: "retry",
@@ -9481,6 +9714,7 @@ var BuildStage = class {
 
 // src/autonomous/stages/verify.ts
 init_esm_shims();
+init_git_inspector();
 var MAX_VERIFY_RETRIES = 3;
 var APP_ROUTER_RE = /^(?:src\/)?app\/((?:.*\/)?api\/.*?)\/route\.[jt]sx?$/;
 var PAGES_ROUTER_RE = /^(?:src\/)?pages\/(api\/.*?)\.[jt]sx?$/;
@@ -9663,19 +9897,53 @@ function detectEndpoints(changedFiles) {
 
 // src/autonomous/stages/finalize.ts
 init_esm_shims();
+init_git_inspector();
 var FinalizeStage = class {
   id = "FINALIZE";
   async enter(ctx) {
+    if (ctx.state.finalizeCheckpoint === "committed") {
+      return { action: "advance" };
+    }
+    const previousHead = ctx.state.git.expectedHead ?? ctx.state.git.initHead;
+    if (previousHead) {
+      const headResult = await gitHead(ctx.root);
+      if (headResult.ok && headResult.data.hash !== previousHead) {
+        const treeResult = await gitDiffTreeNames(ctx.root, headResult.data.hash);
+        const ticketId = ctx.state.ticket?.id;
+        if (ticketId) {
+          const ticketPath = `.story/tickets/${ticketId}.json`;
+          if (treeResult.ok && !treeResult.data.includes(ticketPath)) {
+          } else {
+            ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
+            return this.handleCommit(ctx, { completedAction: "commit_done", commitHash: headResult.data.hash });
+          }
+        }
+        const issueId = ctx.state.currentIssue?.id;
+        if (issueId) {
+          const issuePath = `.story/issues/${issueId}.json`;
+          if (treeResult.ok && !treeResult.data.includes(issuePath)) {
+          } else {
+            ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
+            return this.handleCommit(ctx, { completedAction: "commit_done", commitHash: headResult.data.hash });
+          }
+        }
+        if (!ticketId && !issueId) {
+          ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
+          return this.handleCommit(ctx, { completedAction: "commit_done", commitHash: headResult.data.hash });
+        }
+      }
+    }
     return {
       instruction: [
         "# Finalize",
         "",
         "Code review passed. Time to commit.",
         "",
-        ctx.state.ticket ? `1. Update ticket ${ctx.state.ticket.id} status to "complete" in .story/` : "",
-        ctx.state.currentIssue ? `1. Ensure issue ${ctx.state.currentIssue.id} status is "resolved" in .story/issues/` : "",
-        "2. Stage only the files you created or modified for this work (code + .story/ changes). Do NOT use `git add -A` or `git add .`",
-        '3. Call me with completedAction: "files_staged"'
+        "1. Run `git reset` to clear the staging area (ensures no stale files from prior operations)",
+        ctx.state.ticket ? `2. Update ticket ${ctx.state.ticket.id} status to "complete" in .story/` : "",
+        ctx.state.currentIssue ? `2. Ensure .story/issues/${ctx.state.currentIssue.id}.json is updated with status: "resolved"` : "",
+        "3. Stage only the files you modified for this fix (code + .story/ changes). Do NOT use `git add -A` or `git add .`",
+        '4. Call me with completedAction: "files_staged"'
       ].filter(Boolean).join("\n"),
       reminders: [
         ctx.state.currentIssue ? "Stage both code changes and .story/ issue update in the same commit. Only stage files related to this fix." : "Stage both code changes and .story/ ticket update in the same commit. Only stage files related to this ticket."
@@ -9696,6 +9964,9 @@ var FinalizeStage = class {
       return this.handlePrecommit(ctx);
     }
     if (action === "commit_done") {
+      if (!checkpoint) {
+        ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
+      }
       return this.handleCommit(ctx, report);
     }
     return {
@@ -9709,12 +9980,12 @@ var FinalizeStage = class {
       return {
         action: "retry",
         instruction: [
-          "Files staged. Now run pre-commit checks.",
+          "Files staged. Now commit.",
           "",
-          'Run any pre-commit hooks or linting, then call me with completedAction: "precommit_passed".',
-          'If pre-commit fails, fix the issues, re-stage, and call me with completedAction: "files_staged" again.'
-        ].join("\n"),
-        reminders: ["Verify staged set is intact after pre-commit hooks."]
+          ctx.state.ticket ? `Commit with message: "feat: <description> (${ctx.state.ticket.id})"` : "Commit with a descriptive message.",
+          "",
+          'Call me with completedAction: "commit_done" and include the commitHash.'
+        ].join("\n")
       };
     }
     const stagedResult = await gitDiffCachedNames(ctx.root);
@@ -9749,15 +10020,14 @@ var FinalizeStage = class {
       return { action: "retry", instruction: 'No files are staged. Stage your changes and call me again with completedAction: "files_staged".' };
     }
     const baselineUntracked = ctx.state.git.baseline?.untrackedPaths ?? [];
-    let overlapOverridden = false;
     if (baselineUntracked.length > 0) {
       const sessionTicketPath = ctx.state.ticket?.id ? `.story/tickets/${ctx.state.ticket.id}.json` : null;
+      const sessionIssuePath = ctx.state.currentIssue?.id ? `.story/issues/${ctx.state.currentIssue.id}.json` : null;
       const overlap = stagedResult.data.filter(
-        (f) => baselineUntracked.includes(f) && f !== sessionTicketPath
+        (f) => baselineUntracked.includes(f) && f !== sessionTicketPath && f !== sessionIssuePath
       );
       if (overlap.length > 0) {
         if (report.overrideOverlap) {
-          overlapOverridden = true;
         } else {
           return {
             action: "retry",
@@ -9787,17 +10057,17 @@ var FinalizeStage = class {
       }
     }
     ctx.writeState({
-      finalizeCheckpoint: overlapOverridden ? "staged_override" : "staged"
+      finalizeCheckpoint: "precommit_passed"
     });
     return {
       action: "retry",
       instruction: [
-        "Files staged. Now run pre-commit checks.",
+        "Files staged. Now commit.",
         "",
-        'Run any pre-commit hooks or linting, then call me with completedAction: "precommit_passed".',
-        'If pre-commit fails, fix the issues, re-stage, and call me with completedAction: "files_staged" again.'
-      ].join("\n"),
-      reminders: ["Verify staged set is intact after pre-commit hooks."]
+        ctx.state.ticket ? `Commit with message: "feat: <description> (${ctx.state.ticket.id})"` : "Commit with a descriptive message.",
+        "",
+        'Call me with completedAction: "commit_done" and include the commitHash.'
+      ].join("\n")
     };
   }
   async handlePrecommit(ctx) {
@@ -9814,8 +10084,9 @@ var FinalizeStage = class {
       const baselineUntracked = ctx.state.git.baseline?.untrackedPaths ?? [];
       if (baselineUntracked.length > 0) {
         const sessionTicketPath = ctx.state.ticket?.id ? `.story/tickets/${ctx.state.ticket.id}.json` : null;
+        const sessionIssuePath = ctx.state.currentIssue?.id ? `.story/issues/${ctx.state.currentIssue.id}.json` : null;
         const overlap = stagedResult.data.filter(
-          (f) => baselineUntracked.includes(f) && f !== sessionTicketPath
+          (f) => baselineUntracked.includes(f) && f !== sessionTicketPath && f !== sessionIssuePath
         );
         if (overlap.length > 0) {
           ctx.writeState({ finalizeCheckpoint: null });
@@ -9886,6 +10157,7 @@ var FinalizeStage = class {
         finalizeCheckpoint: "committed",
         resolvedIssues: [...ctx.state.resolvedIssues ?? [], currentIssue.id],
         currentIssue: null,
+        ticketStartedAt: null,
         git: {
           ...ctx.state.git,
           mergeBase: normalizedHash,
@@ -9895,11 +10167,20 @@ var FinalizeStage = class {
       ctx.appendEvent("commit", { commitHash: normalizedHash, issueId: currentIssue.id });
       return { action: "goto", target: "COMPLETE" };
     }
-    const completedTicket = ctx.state.ticket ? { id: ctx.state.ticket.id, title: ctx.state.ticket.title, commitHash: normalizedHash, risk: ctx.state.ticket.risk, realizedRisk: ctx.state.ticket.realizedRisk } : void 0;
+    const completedTicket = ctx.state.ticket ? {
+      id: ctx.state.ticket.id,
+      title: ctx.state.ticket.title,
+      commitHash: normalizedHash,
+      risk: ctx.state.ticket.risk,
+      realizedRisk: ctx.state.ticket.realizedRisk,
+      startedAt: ctx.state.ticketStartedAt ?? void 0,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    } : void 0;
     ctx.writeState({
       finalizeCheckpoint: "committed",
       completedTickets: completedTicket ? [...ctx.state.completedTickets, completedTicket] : ctx.state.completedTickets,
       ticket: void 0,
+      ticketStartedAt: null,
       git: {
         ...ctx.state.git,
         mergeBase: normalizedHash,
@@ -9933,7 +10214,7 @@ var CompleteStage = class {
         target: "HANDOVER",
         result: {
           instruction: [
-            `# Ticket Complete \u2014 ${mode} mode session ending`,
+            `# Ticket Complete -- ${mode} mode session ending`,
             "",
             `Ticket **${ctx.state.ticket?.id}** completed. Write a brief session handover.`,
             "",
@@ -9944,36 +10225,23 @@ var CompleteStage = class {
         }
       };
     }
-    const handoverInterval = ctx.state.config.handoverInterval ?? 5;
-    if (handoverInterval > 0 && totalWorkDone > 0 && totalWorkDone % handoverInterval === 0) {
-      try {
-        const { handleHandoverCreate: handleHandoverCreate3 } = await Promise.resolve().then(() => (init_handover(), handover_exports));
-        const completedIds = ctx.state.completedTickets.map((t) => t.id).join(", ");
-        const resolvedIds = (ctx.state.resolvedIssues ?? []).join(", ");
-        const content = [
-          `# Checkpoint \u2014 ${totalWorkDone} items completed`,
-          "",
-          `**Session:** ${ctx.state.sessionId}`,
-          ...completedIds ? [`**Tickets:** ${completedIds}`] : [],
-          ...resolvedIds ? [`**Issues resolved:** ${resolvedIds}`] : [],
-          "",
-          "This is an automatic mid-session checkpoint. The session is still active."
-        ].join("\n");
-        await handleHandoverCreate3(content, "checkpoint", "md", ctx.root);
-      } catch {
-      }
-      try {
-        const { loadProject: loadProject2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
-        const { saveSnapshot: saveSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
-        const loadResult = await loadProject2(ctx.root);
-        await saveSnapshot2(ctx.root, loadResult);
-      } catch {
-      }
-      ctx.appendEvent("checkpoint", { ticketsDone, issuesDone, totalWorkDone, interval: handoverInterval });
+    await this.tryCheckpoint(ctx, totalWorkDone, ticketsDone, issuesDone);
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch (err) {
+      return {
+        action: "goto",
+        target: "HANDOVER",
+        result: {
+          instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Ending session -- write a handover noting the error.`,
+          reminders: [],
+          transitionedFrom: "COMPLETE"
+        }
+      };
     }
-    const { state: projectState } = await ctx.loadProject();
-    let nextTarget;
     const targetedRemaining = isTargetedMode(ctx.state) ? getRemainingTargets(ctx.state) : null;
+    let nextTarget;
     if (targetedRemaining !== null) {
       nextTarget = targetedRemaining.length === 0 ? "HANDOVER" : "PICK_TICKET";
     } else if (maxTickets > 0 && totalWorkDone >= maxTickets) {
@@ -9988,66 +10256,118 @@ var CompleteStage = class {
       }
     }
     if (nextTarget === "HANDOVER") {
-      const postComplete = ctx.state.resolvedPostComplete ?? ctx.recipe.postComplete;
-      const postResult = findFirstPostComplete(postComplete, ctx);
-      if (postResult.kind === "found") {
-        ctx.writeState({ pipelinePhase: "postComplete" });
-        return { action: "goto", target: postResult.stage.id };
+      return this.buildHandoverResult(ctx, targetedRemaining, ticketsDone, issuesDone);
+    }
+    if (targetedRemaining !== null) {
+      return this.buildTargetedPickResult(ctx, targetedRemaining, projectState);
+    }
+    return this.buildStandardPickResult(ctx, projectState, ticketsDone, maxTickets);
+  }
+  async report(ctx, _report) {
+    return this.enter(ctx);
+  }
+  // ---------------------------------------------------------------------------
+  // Checkpoint -- mid-session handover + snapshot (best-effort)
+  // ---------------------------------------------------------------------------
+  async tryCheckpoint(ctx, totalWorkDone, ticketsDone, issuesDone) {
+    const handoverInterval = ctx.state.config.handoverInterval ?? 5;
+    if (handoverInterval <= 0 || totalWorkDone <= 0 || totalWorkDone % handoverInterval !== 0) return;
+    try {
+      const { handleHandoverCreate: handleHandoverCreate3 } = await Promise.resolve().then(() => (init_handover(), handover_exports));
+      const completedIds = ctx.state.completedTickets.map((t) => t.id).join(", ");
+      const resolvedIds = (ctx.state.resolvedIssues ?? []).join(", ");
+      const content = [
+        `# Checkpoint -- ${totalWorkDone} items completed`,
+        "",
+        `**Session:** ${ctx.state.sessionId}`,
+        ...completedIds ? [`**Tickets:** ${completedIds}`] : [],
+        ...resolvedIds ? [`**Issues resolved:** ${resolvedIds}`] : [],
+        "",
+        "This is an automatic mid-session checkpoint. The session is still active."
+      ].join("\n");
+      await handleHandoverCreate3(content, "checkpoint", "md", ctx.root);
+    } catch {
+    }
+    try {
+      const { loadProject: loadProject2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
+      const { saveSnapshot: saveSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+      const loadResult = await loadProject2(ctx.root);
+      await saveSnapshot2(ctx.root, loadResult);
+    } catch {
+    }
+    ctx.appendEvent("checkpoint", { ticketsDone, issuesDone, totalWorkDone, interval: handoverInterval });
+  }
+  // ---------------------------------------------------------------------------
+  // HANDOVER instruction -- session ending
+  // ---------------------------------------------------------------------------
+  buildHandoverResult(ctx, targetedRemaining, ticketsDone, issuesDone) {
+    const postComplete = ctx.state.resolvedPostComplete ?? ctx.recipe.postComplete;
+    const postResult = findFirstPostComplete(postComplete, ctx);
+    if (postResult.kind === "found") {
+      ctx.writeState({ pipelinePhase: "postComplete" });
+      return { action: "goto", target: postResult.stage.id };
+    }
+    const handoverHeader = targetedRemaining !== null ? `# Targeted Session Complete -- All ${ctx.state.targetWork.length} target(s) done` : `# Session Complete -- ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`;
+    return {
+      action: "goto",
+      target: "HANDOVER",
+      result: {
+        instruction: [
+          handoverHeader,
+          "",
+          "Write a session handover summarizing what was accomplished, decisions made, and what's next.",
+          "",
+          'Call me with completedAction: "handover_written" and include the content in handoverContent.'
+        ].join("\n"),
+        reminders: [],
+        transitionedFrom: "COMPLETE",
+        contextAdvice: "ok"
       }
-      const handoverHeader = targetedRemaining !== null ? `# Targeted Session Complete -- All ${ctx.state.targetWork.length} target(s) done` : `# Session Complete \u2014 ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`;
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Targeted PICK_TICKET instruction
+  // ---------------------------------------------------------------------------
+  buildTargetedPickResult(ctx, targetedRemaining, projectState) {
+    const { text: candidatesText, firstReady } = buildTargetedCandidatesText(targetedRemaining, projectState);
+    if (!firstReady) {
       return {
         action: "goto",
         target: "HANDOVER",
         result: {
-          instruction: [
-            handoverHeader,
-            "",
-            "Write a session handover summarizing what was accomplished, decisions made, and what's next.",
-            "",
-            'Call me with completedAction: "handover_written" and include the content in handoverContent.'
-          ].join("\n"),
+          instruction: buildTargetedStuckHandover(candidatesText, ctx.state.sessionId),
           reminders: [],
-          transitionedFrom: "COMPLETE",
-          contextAdvice: "ok"
+          transitionedFrom: "COMPLETE"
         }
       };
     }
-    if (targetedRemaining !== null) {
-      const { text: candidatesText2, firstReady } = buildTargetedCandidatesText(targetedRemaining, projectState);
-      if (!firstReady) {
-        return {
-          action: "goto",
-          target: "HANDOVER",
-          result: {
-            instruction: buildTargetedStuckHandover(candidatesText2, ctx.state.sessionId),
-            reminders: [],
-            transitionedFrom: "COMPLETE"
-          }
-        };
+    const precomputed = { text: candidatesText, firstReady };
+    const targetedInstruction = buildTargetedPickInstruction(targetedRemaining, projectState, ctx.state.sessionId, precomputed);
+    return {
+      action: "goto",
+      target: "PICK_TICKET",
+      result: {
+        instruction: [
+          `# Item Complete -- Continuing (${ctx.state.targetWork.length - targetedRemaining.length}/${ctx.state.targetWork.length} targets done)`,
+          "",
+          "Do NOT stop. Do NOT ask the user. Continue immediately with the next target.",
+          "",
+          targetedInstruction
+        ].join("\n"),
+        reminders: [
+          "Do NOT stop or summarize. Call autonomous_guide IMMEDIATELY to pick the next target.",
+          "Do NOT ask the user for confirmation.",
+          "You are in targeted auto mode -- pick ONLY from the listed items."
+        ],
+        transitionedFrom: "COMPLETE",
+        contextAdvice: "ok"
       }
-      const precomputed = { text: candidatesText2, firstReady };
-      const targetedInstruction = buildTargetedPickInstruction(targetedRemaining, projectState, ctx.state.sessionId, precomputed);
-      return {
-        action: "goto",
-        target: "PICK_TICKET",
-        result: {
-          instruction: [
-            `# Item Complete -- Continuing (${ctx.state.targetWork.length - targetedRemaining.length}/${ctx.state.targetWork.length} targets done)`,
-            "",
-            "Do NOT stop. Do NOT ask the user. Continue immediately with the next target.",
-            "",
-            targetedInstruction
-          ].join("\n"),
-          reminders: [
-            "Do NOT stop or summarize. Call autonomous_guide IMMEDIATELY to pick the next target.",
-            "Do NOT ask the user for confirmation.",
-            "You are in targeted auto mode -- pick ONLY from the listed items."
-          ],
-          transitionedFrom: "COMPLETE",
-          contextAdvice: "ok"
-        }
-      };
-    }
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Standard auto PICK_TICKET instruction
+  // ---------------------------------------------------------------------------
+  buildStandardPickResult(ctx, projectState, ticketsDone, maxTickets) {
     const candidates = nextTickets(projectState, 5);
     let candidatesText = "";
     if (candidates.kind === "found") {
@@ -10061,7 +10381,7 @@ var CompleteStage = class {
       target: "PICK_TICKET",
       result: {
         instruction: [
-          `# Ticket Complete \u2014 Continuing (${ticketsDone}/${maxTickets})`,
+          `# Ticket Complete -- Continuing (${ticketsDone}/${maxTickets})`,
           "",
           "Do NOT stop. Do NOT ask the user. Continue immediately with the next ticket.",
           "",
@@ -10075,16 +10395,13 @@ var CompleteStage = class {
         reminders: [
           "Do NOT stop or summarize. Call autonomous_guide IMMEDIATELY to pick the next ticket.",
           "Do NOT ask the user for confirmation.",
-          "You are in autonomous mode \u2014 continue working until all tickets are done or the session limit is reached."
+          "You are in autonomous mode -- continue working until all tickets are done or the session limit is reached."
         ],
         transitionedFrom: "COMPLETE",
         contextAdvice: "ok"
       }
     };
   }
-  async report(ctx, _report) {
-    return this.enter(ctx);
-  }
 };
 
 // src/autonomous/stages/lesson-capture.ts
@@ -10200,7 +10517,32 @@ var IssueFixStage = class {
     if (!issue) {
       return { action: "goto", target: "PICK_TICKET" };
     }
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch {
+      return {
+        instruction: [
+          "# Fix Issue",
+          "",
+          `**${issue.id}**: ${issue.title} (severity: ${issue.severity})`,
+          "",
+          "(Warning: could not load full issue details from .story/ -- using session state.)",
+          "",
+          'Fix this issue, then update its status to "resolved" in `.story/issues/`.',
+          "Add a resolution description explaining the fix.",
+          "",
+          "When done, call `claudestory_autonomous_guide` with:",
+          "```json",
+          `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "issue_fixed" } }`,
+          "```"
+        ].join("\n"),
+        reminders: [
+          'Update the issue JSON: set status to "resolved", add resolution text, set resolvedDate.',
+          "Do NOT ask the user for confirmation."
+        ]
+      };
+    }
     const fullIssue = projectState.issues.find((i) => i.id === issue.id);
     const details = fullIssue ? [
       `**${fullIssue.id}**: ${fullIssue.title}`,
@@ -10235,7 +10577,12 @@ var IssueFixStage = class {
     if (!issue) {
       return { action: "goto", target: "PICK_TICKET" };
     }
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch (err) {
+      return { action: "retry", instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Check .story/ files for corruption, then report again.` };
+    }
     const current = projectState.issues.find((i) => i.id === issue.id);
     if (!current || current.status !== "resolved") {
       return {
@@ -10244,6 +10591,10 @@ var IssueFixStage = class {
         reminders: ["Set status to 'resolved', add resolution text, set resolvedDate."]
       };
     }
+    const enableCodeReview = !!ctx.recipe.stages.ISSUE_FIX?.enableCodeReview;
+    if (enableCodeReview) {
+      return { action: "goto", target: "CODE_REVIEW" };
+    }
     return {
       action: "goto",
       target: "FINALIZE",
@@ -10253,9 +10604,10 @@ var IssueFixStage = class {
           "",
           `Issue ${issue.id} resolved. Time to commit.`,
           "",
-          `1. Ensure .story/issues/${issue.id}.json is updated with status: "resolved"`,
-          "2. Stage only the files you modified for this fix (code + .story/ changes). Do NOT use `git add -A` or `git add .`",
-          '3. Call me with completedAction: "files_staged"'
+          "1. Run `git reset` to clear the staging area (ensures no stale files from prior operations)",
+          `2. Ensure .story/issues/${issue.id}.json is updated with status: "resolved"`,
+          "3. Stage only the files you modified for this fix (code + .story/ changes). Do NOT use `git add -A` or `git add .`",
+          '4. Call me with completedAction: "files_staged"'
         ].join("\n"),
         reminders: ["Stage both code changes and .story/ issue update in the same commit. Only stage files related to this fix."],
         transitionedFrom: "ISSUE_FIX"
@@ -10273,7 +10625,12 @@ var IssueSweepStage = class {
     return !issueConfig?.enabled;
   }
   async enter(ctx) {
-    const { state: projectState } = await ctx.loadProject();
+    let projectState;
+    try {
+      ({ state: projectState } = await ctx.loadProject());
+    } catch {
+      return { action: "goto", target: "HANDOVER" };
+    }
     const allIssues = projectState.issues.filter((i) => i.status === "open");
     if (allIssues.length === 0) {
       return { action: "goto", target: "HANDOVER" };
@@ -10325,7 +10682,12 @@ var IssueSweepStage = class {
     }
     const current = sweep.current;
     if (current) {
-      const { state: verifyState } = await ctx.loadProject();
+      let verifyState;
+      try {
+        ({ state: verifyState } = await ctx.loadProject());
+      } catch (err) {
+        return { action: "retry", instruction: `Failed to load project state: ${err instanceof Error ? err.message : String(err)}. Check .story/ files, then report again.` };
+      }
       const currentIssue = verifyState.issues.find((i) => i.id === current);
       if (currentIssue && currentIssue.status === "open") {
         return {
@@ -10344,7 +10706,16 @@ var IssueSweepStage = class {
         ctx.appendEvent("issue_sweep_complete", { resolved: resolved.length });
         return { action: "goto", target: "HANDOVER" };
       }
-      const { state: projectState } = await ctx.loadProject();
+      let projectState;
+      try {
+        ({ state: projectState } = await ctx.loadProject());
+      } catch {
+        return {
+          action: "retry",
+          instruction: `Issue ${next} is next. Fix it and report again. (Could not load full details from .story/.)`,
+          reminders: ["Set status to 'resolved' and add a resolution description."]
+        };
+      }
       const nextIssue = projectState.issues.find((i) => i.id === next);
       return {
         action: "retry",
@@ -10368,8 +10739,292 @@ Impact: ${nextIssue.impact}` : ""}` : `Fix issue ${next}.`,
 // src/autonomous/stages/handover.ts
 init_esm_shims();
 init_handover();
-import { writeFileSync as writeFileSync4 } from "fs";
+init_git_inspector();
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join18 } from "path";
+
+// src/autonomous/resume-marker.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, existsSync as existsSync11 } from "fs";
 import { join as join17 } from "path";
+var MARKER_FILENAME = "autonomous-resume.md";
+function sanitize(input, maxLen = 120) {
+  return input.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, maxLen);
+}
+function writeResumeMarker(root, sessionId, state) {
+  try {
+    const rulesDir = join17(root, ".claude", "rules");
+    mkdirSync4(rulesDir, { recursive: true });
+    const ticketInfo = state.ticket ? `Working on: ${sanitize(state.ticket.id, 20)} (${sanitize(state.ticket.title)})` : "Between tickets";
+    const progress = `Progress: ${state.completedTickets.length} tickets completed, ${(state.resolvedIssues ?? []).length} issues resolved`;
+    const lines = [
+      "CRITICAL: An autonomous coding session is active and waiting to resume.",
+      "",
+      `Session: ${sessionId}`,
+      ticketInfo,
+      progress
+    ];
+    if (state.preCompactState) {
+      lines.push(`State before compaction: ${state.preCompactState}`);
+    }
+    lines.push(
+      "",
+      "You MUST call `claudestory_autonomous_guide` with:",
+      `{"sessionId": "${sessionId}", "action": "resume"}`,
+      "",
+      "Do NOT do any other work until you have called this.",
+      "Do NOT manually create tickets, issues, or handovers.",
+      "The guide manages your workflow."
+    );
+    const content = lines.join("\n") + "\n";
+    writeFileSync4(join17(rulesDir, MARKER_FILENAME), content, "utf-8");
+  } catch {
+  }
+}
+function removeResumeMarker(root) {
+  try {
+    const markerPath = join17(root, ".claude", "rules", MARKER_FILENAME);
+    if (existsSync11(markerPath)) unlinkSync3(markerPath);
+  } catch {
+  }
+}
+
+// src/core/session-report-formatter.ts
+init_esm_shims();
+function formatSessionReport(data, format) {
+  const { state, events, planContent, gitLog } = data;
+  if (format === "json") {
+    return JSON.stringify({
+      ok: true,
+      data: {
+        summary: buildSummaryData(state),
+        ticketProgression: state.completedTickets,
+        reviewStats: state.reviews,
+        events: events.events.slice(-50),
+        malformedEventCount: events.malformedCount,
+        contextPressure: state.contextPressure,
+        git: {
+          branch: state.git.branch,
+          initHead: state.git.initHead,
+          commits: gitLog
+        },
+        problems: buildProblems(state, events)
+      }
+    }, null, 2);
+  }
+  const sections = [];
+  sections.push(buildSummarySection(state));
+  sections.push(buildTicketSection(state));
+  sections.push(buildReviewSection(state));
+  sections.push(buildEventSection(events));
+  sections.push(buildPressureSection(state));
+  sections.push(buildGitSection(state, gitLog));
+  sections.push(buildProblemsSection(state, events));
+  return sections.join("\n\n---\n\n");
+}
+function buildSummaryData(state) {
+  return {
+    sessionId: state.sessionId,
+    mode: state.mode ?? "auto",
+    recipe: state.recipe,
+    status: state.status,
+    terminationReason: state.terminationReason,
+    startedAt: state.startedAt,
+    lastGuideCall: state.lastGuideCall,
+    guideCallCount: state.guideCallCount,
+    ticketsCompleted: state.completedTickets.length
+  };
+}
+function buildSummarySection(state) {
+  const duration = state.startedAt && state.lastGuideCall ? formatDuration(state.startedAt, state.lastGuideCall) : "unknown";
+  return [
+    "## Session Summary",
+    "",
+    `- **ID:** ${state.sessionId}`,
+    `- **Mode:** ${state.mode ?? "auto"}`,
+    `- **Recipe:** ${state.recipe}`,
+    `- **Status:** ${state.status}${state.terminationReason ? ` (${state.terminationReason})` : ""}`,
+    `- **Duration:** ${duration}`,
+    `- **Guide calls:** ${state.guideCallCount}`,
+    `- **Tickets completed:** ${state.completedTickets.length}`
+  ].join("\n");
+}
+function buildTicketSection(state) {
+  if (state.completedTickets.length === 0) {
+    const current = state.ticket;
+    if (current) {
+      return [
+        "## Ticket Progression",
+        "",
+        `In progress: **${current.id}** \u2014 ${current.title} (risk: ${current.risk ?? "unknown"})`
+      ].join("\n");
+    }
+    return "## Ticket Progression\n\nNo tickets completed.";
+  }
+  const lines = ["## Ticket Progression", ""];
+  for (const t of state.completedTickets) {
+    const risk = t.realizedRisk ? `${t.risk ?? "?"} \u2192 ${t.realizedRisk}` : t.risk ?? "unknown";
+    const duration = t.startedAt && t.completedAt ? formatDuration(t.startedAt, t.completedAt) : null;
+    const durationPart = duration ? ` | duration: ${duration}` : "";
+    lines.push(`- **${t.id}:** ${t.title} | risk: ${risk}${durationPart} | commit: \`${t.commitHash ?? "?"}\``);
+  }
+  return lines.join("\n");
+}
+function buildReviewSection(state) {
+  const plan = state.reviews.plan;
+  const code = state.reviews.code;
+  if (plan.length === 0 && code.length === 0) {
+    return "## Review Stats\n\nNo reviews recorded.";
+  }
+  const lines = ["## Review Stats", ""];
+  if (plan.length > 0) {
+    lines.push(`**Plan reviews:** ${plan.length} round(s)`);
+    for (const r of plan) {
+      lines.push(`  - Round ${r.round}: ${r.verdict} (${r.findingCount} findings, ${r.criticalCount} critical, ${r.majorCount} major) \u2014 ${r.reviewer}`);
+    }
+  }
+  if (code.length > 0) {
+    lines.push(`**Code reviews:** ${code.length} round(s)`);
+    for (const r of code) {
+      lines.push(`  - Round ${r.round}: ${r.verdict} (${r.findingCount} findings, ${r.criticalCount} critical, ${r.majorCount} major) \u2014 ${r.reviewer}`);
+    }
+  }
+  const totalFindings = [...plan, ...code].reduce((sum, r) => sum + r.findingCount, 0);
+  lines.push("", `**Total findings:** ${totalFindings}`);
+  return lines.join("\n");
+}
+function buildEventSection(events) {
+  if (events.events.length === 0 && events.malformedCount === 0) {
+    return "## Event Timeline\n\nNot available.";
+  }
+  const capped = events.events.slice(-50);
+  const omitted = events.events.length - capped.length;
+  const lines = ["## Event Timeline", ""];
+  if (omitted > 0) {
+    lines.push(`*${omitted} earlier events omitted*`, "");
+  }
+  for (const e of capped) {
+    const ts = e.timestamp ? e.timestamp.slice(11, 19) : "??:??:??";
+    const detail = e.data ? Object.entries(e.data).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" ") : "";
+    lines.push(`- \`${ts}\` [${e.type}] ${detail}`.trimEnd());
+  }
+  if (events.malformedCount > 0) {
+    lines.push("", `*${events.malformedCount} malformed event line(s) skipped*`);
+  }
+  return lines.join("\n");
+}
+function buildPressureSection(state) {
+  const p = state.contextPressure;
+  return [
+    "## Context Pressure",
+    "",
+    `- **Level:** ${p.level}`,
+    `- **Guide calls:** ${p.guideCallCount}`,
+    `- **Tickets completed:** ${p.ticketsCompleted}`,
+    `- **Compactions:** ${p.compactionCount}`,
+    `- **Events log:** ${p.eventsLogBytes} bytes`
+  ].join("\n");
+}
+function buildGitSection(state, gitLog) {
+  const lines = [
+    "## Git Summary",
+    "",
+    `- **Branch:** ${state.git.branch ?? "unknown"}`,
+    `- **Init HEAD:** \`${state.git.initHead ?? "?"}\``,
+    `- **Expected HEAD:** \`${state.git.expectedHead ?? "?"}\``
+  ];
+  if (gitLog && gitLog.length > 0) {
+    lines.push("", "**Commits:**");
+    for (const c of gitLog) {
+      lines.push(`- ${c}`);
+    }
+  } else {
+    lines.push("", "Commits: Not available.");
+  }
+  return lines.join("\n");
+}
+function buildProblems(state, events) {
+  const problems = [];
+  if (state.terminationReason && state.terminationReason !== "normal") {
+    problems.push(`Abnormal termination: ${state.terminationReason}`);
+  }
+  if (events.malformedCount > 0) {
+    problems.push(`${events.malformedCount} malformed event line(s) in events.log`);
+  }
+  for (const e of events.events) {
+    if (e.type.includes("error") || e.type.includes("exhaustion")) {
+      problems.push(`[${e.type}] ${e.timestamp ?? ""} ${JSON.stringify(e.data)}`);
+    } else if (e.data?.result === "exhaustion") {
+      problems.push(`[${e.type}] exhaustion at ${e.timestamp ?? ""}`);
+    }
+  }
+  if (state.deferralsUnfiled) {
+    problems.push("Session has unfiled deferrals");
+  }
+  return problems;
+}
+function buildProblemsSection(state, events) {
+  const problems = buildProblems(state, events);
+  if (problems.length === 0) {
+    return "## Problems\n\nNone detected.";
+  }
+  return ["## Problems", "", ...problems.map((p) => `- ${p}`)].join("\n");
+}
+function formatCompactReport(data) {
+  const { state, remainingWork } = data;
+  const endTime = data.endedAt ?? state.lastGuideCall ?? (/* @__PURE__ */ new Date()).toISOString();
+  const duration = state.startedAt ? formatDuration(state.startedAt, endTime) : "unknown";
+  const ticketCount = state.completedTickets.length;
+  const issueCount = (state.resolvedIssues ?? []).length;
+  const reviewRounds = state.reviews.plan.length + state.reviews.code.length;
+  const totalFindings = [...state.reviews.plan, ...state.reviews.code].reduce((s, r) => s + r.findingCount, 0);
+  const compactions = state.contextPressure?.compactionCount ?? 0;
+  const lines = [
+    "## Session Report",
+    "",
+    `**Duration:** ${duration} | **Tickets:** ${ticketCount} | **Issues:** ${issueCount} | **Reviews:** ${reviewRounds} rounds (${totalFindings} findings) | **Compactions:** ${compactions}`
+  ];
+  if (ticketCount > 0) {
+    lines.push("", "### Completed", "| Ticket | Title | Duration |", "|--------|-------|----------|");
+    for (const t of state.completedTickets) {
+      const ticketDuration = t.startedAt && t.completedAt ? formatDuration(t.startedAt, t.completedAt) : "--";
+      const safeTitle = (t.title ?? "").replace(/\|/g, "\\|");
+      lines.push(`| ${t.id} | ${safeTitle} | ${ticketDuration} |`);
+    }
+    const timings = state.completedTickets.filter((t) => t.startedAt && t.completedAt).map((t) => new Date(t.completedAt).getTime() - new Date(t.startedAt).getTime());
+    if (timings.length > 0) {
+      const avgMs = timings.reduce((a, b) => a + b, 0) / timings.length;
+      const avgMins = Math.round(avgMs / 6e4);
+      lines.push("", `**Avg time per ticket:** ${avgMins}m`);
+    }
+  }
+  if (remainingWork && (remainingWork.tickets.length > 0 || remainingWork.issues.length > 0)) {
+    lines.push("", "### What's Left");
+    for (const t of remainingWork.tickets) {
+      lines.push(`- ${t.id}: ${t.title} (unblocked)`);
+    }
+    for (const i of remainingWork.issues) {
+      lines.push(`- ${i.id}: ${i.title} (${i.severity})`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatDuration(start, end) {
+  try {
+    const ms = new Date(end).getTime() - new Date(start).getTime();
+    if (isNaN(ms) || ms < 0) return "unknown";
+    const mins = Math.floor(ms / 6e4);
+    if (mins < 60) return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    return `${hours}h ${mins % 60}m`;
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/autonomous/stages/handover.ts
+init_project_loader();
+init_queries();
 var HandoverStage = class {
   id = "HANDOVER";
   async enter(ctx) {
@@ -10400,8 +11055,8 @@ var HandoverStage = class {
     } catch {
       handoverFailed = true;
       try {
-        const fallbackPath = join17(ctx.dir, "handover-fallback.md");
-        writeFileSync4(fallbackPath, content, "utf-8");
+        const fallbackPath = join18(ctx.dir, "handover-fallback.md");
+        writeFileSync5(fallbackPath, content, "utf-8");
       } catch {
       }
     }
@@ -10427,6 +11082,19 @@ var HandoverStage = class {
       issuesResolved: (ctx.state.resolvedIssues ?? []).length,
       handoverFailed
     });
+    removeResumeMarker(ctx.root);
+    let reportSection = "";
+    try {
+      const { state: projectState } = await loadProject(ctx.root);
+      const nextResult = nextTickets(projectState, 5);
+      const openIssues = projectState.issues.filter((i) => i.status === "open" || i.status === "inprogress").slice(0, 5);
+      const remainingWork = {
+        tickets: nextResult.kind === "found" ? nextResult.candidates.map((c) => ({ id: c.ticket.id, title: c.ticket.title })) : [],
+        issues: openIssues.map((i) => ({ id: i.id, title: i.title, severity: i.severity }))
+      };
+      reportSection = "\n\n" + formatCompactReport({ state: ctx.state, endedAt: (/* @__PURE__ */ new Date()).toISOString(), remainingWork });
+    } catch {
+    }
     const ticketsDone = ctx.state.completedTickets.length;
     const issuesDone = (ctx.state.resolvedIssues ?? []).length;
     const resolvedList = (ctx.state.resolvedIssues ?? []).map((id) => `- ${id} (resolved)`).join("\n");
@@ -10440,7 +11108,7 @@ var HandoverStage = class {
           "",
           ctx.state.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n"),
           ...resolvedList ? [resolvedList] : []
-        ].join("\n"),
+        ].join("\n") + reportSection,
         reminders: [],
         transitionedFrom: "HANDOVER"
       }
@@ -10474,7 +11142,7 @@ init_queries();
 // src/autonomous/version-check.ts
 init_esm_shims();
 import { readFileSync as readFileSync9 } from "fs";
-import { join as join18, dirname as dirname4 } from "path";
+import { join as join19, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function checkVersionMismatch(runningVersion, installedVersion) {
   if (!installedVersion) return null;
@@ -10486,8 +11154,8 @@ function getInstalledVersion() {
   try {
     const thisFile = fileURLToPath3(import.meta.url);
     const candidates = [
-      join18(dirname4(thisFile), "..", "..", "package.json"),
-      join18(dirname4(thisFile), "..", "package.json")
+      join19(dirname4(thisFile), "..", "..", "package.json"),
+      join19(dirname4(thisFile), "..", "package.json")
     ];
     for (const candidate of candidates) {
       try {
@@ -10503,7 +11171,7 @@ function getInstalledVersion() {
   }
 }
 function getRunningVersion() {
-  return "0.1.61";
+  return "0.1.63";
 }
 
 // src/autonomous/guide.ts
@@ -10522,24 +11190,25 @@ var RECOVERY_MAPPING = {
   CODE_REVIEW: { state: "PLAN", resetPlan: true, resetCode: true },
   FINALIZE: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
   LESSON_CAPTURE: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
-  ISSUE_FIX: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
+  ISSUE_FIX: { state: "ISSUE_FIX", resetPlan: false, resetCode: false },
+  // T-208: self-recover to avoid dangling currentIssue
   ISSUE_SWEEP: { state: "PICK_TICKET", resetPlan: false, resetCode: false }
 };
 function buildGuideRecommendOptions(root) {
   const opts = {};
   try {
-    const handoversDir = join19(root, ".story", "handovers");
+    const handoversDir = join20(root, ".story", "handovers");
     const files = readdirSync4(handoversDir, "utf-8").filter((f) => f.endsWith(".md")).sort();
     if (files.length > 0) {
-      opts.latestHandoverContent = readFileSync10(join19(handoversDir, files[files.length - 1]), "utf-8");
+      opts.latestHandoverContent = readFileSync10(join20(handoversDir, files[files.length - 1]), "utf-8");
     }
   } catch {
   }
   try {
-    const snapshotsDir = join19(root, ".story", "snapshots");
+    const snapshotsDir = join20(root, ".story", "snapshots");
     const snapFiles = readdirSync4(snapshotsDir, "utf-8").filter((f) => f.endsWith(".json")).sort();
     if (snapFiles.length > 0) {
-      const raw = readFileSync10(join19(snapshotsDir, snapFiles[snapFiles.length - 1]), "utf-8");
+      const raw = readFileSync10(join20(snapshotsDir, snapFiles[snapFiles.length - 1]), "utf-8");
       const snap = JSON.parse(raw);
       if (snap.issues) {
         opts.previousOpenIssueCount = snap.issues.filter((i) => i.status !== "resolved").length;
@@ -10617,6 +11286,33 @@ async function recoverPendingMutation(dir, state, root) {
   const mutation = state.pendingProjectMutation;
   if (!mutation || typeof mutation !== "object") return state;
   const m = mutation;
+  if (m.type === "issue_update") {
+    const targetId2 = m.target;
+    const targetValue2 = m.value;
+    const expectedCurrent2 = m.expectedCurrent;
+    try {
+      const { loadProject: loadProject2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
+      const { state: projectState } = await loadProject2(root);
+      const issue = projectState.issues.find((i) => i.id === targetId2);
+      if (issue) {
+        if (issue.status === targetValue2) {
+        } else if (expectedCurrent2 && issue.status === expectedCurrent2) {
+          const { handleIssueUpdate: handleIssueUpdate2 } = await Promise.resolve().then(() => (init_issue2(), issue_exports));
+          await handleIssueUpdate2(targetId2, { status: targetValue2 }, "json", root);
+        } else {
+          appendEvent(dir, {
+            rev: state.revision,
+            type: "mutation_conflict",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: { targetId: targetId2, expected: expectedCurrent2, actual: issue.status, transitionId: m.transitionId }
+          });
+        }
+      }
+    } catch {
+    }
+    const cleared2 = { ...state, pendingProjectMutation: null };
+    return writeSessionSync(dir, cleared2);
+  }
   if (m.type !== "ticket_update") return state;
   const targetId = m.target;
   const targetValue = m.value;
@@ -10892,6 +11588,7 @@ async function handleStart(root, args) {
     reviewBackends: sessionConfig.reviewBackends,
     stages: sessionConfig.stageOverrides
   });
+  removeResumeMarker(root);
   const session = createSession(root, recipe, wsId, sessionConfig);
   const dir = sessionDir(root, session.sessionId);
   try {
@@ -11014,7 +11711,7 @@ Staged: ${stagedResult.data.join(", ")}`
         const passMatch = combined.match(/(\d+)\s*pass/i);
         const failMatch = combined.match(/(\d+)\s*fail/i);
         const passCount = passMatch ? parseInt(passMatch[1], 10) : -1;
-        const failCount = failMatch ? parseInt(failMatch[1], 10) : -1;
+        const failCount = failMatch ? parseInt(failMatch[1], 10) : exitCode === 0 && passCount > 0 ? 0 : -1;
         const output = combined.slice(-500);
         updated = { ...updated, testBaseline: { exitCode, passCount, failCount, summary: output } };
         if (writeTestsEnabled && failCount < 0) {
@@ -11054,7 +11751,7 @@ Staged: ${stagedResult.data.join(", ")}`
       }
     }
     const { state: projectState, warnings } = await loadProject(root);
-    const handoversDir = join19(root, ".story", "handovers");
+    const handoversDir = join20(root, ".story", "handovers");
     const ctx = { state: projectState, warnings, root, handoversDir, format: "md" };
     let handoverText = "";
     try {
@@ -11065,13 +11762,13 @@ Staged: ${stagedResult.data.join(", ")}`
     let recapText = "";
     try {
       const snapshotInfo = await loadLatestSnapshot(root);
-      const recap = buildRecap(projectState, snapshotInfo);
+      const recap = await buildRecap(projectState, snapshotInfo, root);
       if (recap.changes) {
         recapText = "Changes since last snapshot available.";
       }
     } catch {
     }
-    const rulesText = readFileSafe2(join19(root, "RULES.md"));
+    const rulesText = readFileSafe2(join20(root, "RULES.md"));
     const lessonDigest = buildLessonDigest(projectState.lessons);
     const digestParts = [
       handoverText ? `## Recent Handovers
@@ -11087,7 +11784,7 @@ ${rulesText}` : "",
     ].filter(Boolean);
     const digest = digestParts.join("\n\n---\n\n");
     try {
-      writeFileSync5(join19(dir, "context-digest.md"), digest, "utf-8");
+      writeFileSync6(join20(dir, "context-digest.md"), digest, "utf-8");
     } catch {
     }
     if (mode !== "auto" && args.ticketId) {
@@ -11485,8 +12182,18 @@ async function handleResume(root, args) {
       `Cannot validate git state for session ${args.sessionId}. Check git status and try "resume" again, or run "claudestory session stop ${args.sessionId}" to end the session.`
     ));
   }
+  let ownCommitDrift = false;
   if (expectedHead && headResult.data.hash !== expectedHead) {
-    const mapping = RECOVERY_MAPPING[resumeState] ?? { state: "PICK_TICKET", resetPlan: false, resetCode: false };
+    const ancestorCheck = await gitIsAncestor(root, expectedHead, headResult.data.hash);
+    if (ancestorCheck.ok && ancestorCheck.data) {
+      ownCommitDrift = true;
+    }
+  }
+  if (expectedHead && headResult.data.hash !== expectedHead && !ownCommitDrift) {
+    let mapping = RECOVERY_MAPPING[resumeState] ?? { state: "PICK_TICKET", resetPlan: false, resetCode: false };
+    if (info.state.currentIssue && resumeState === "CODE_REVIEW") {
+      mapping = { state: "ISSUE_FIX", resetPlan: false, resetCode: true };
+    }
     const recoveryReviews = {
       plan: mapping.resetPlan ? [] : info.state.reviews.plan,
       code: mapping.resetCode ? [] : info.state.reviews.code
@@ -11514,6 +12221,19 @@ async function handleResume(root, args) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       data: { drift: true, previousState: resumeState, recoveryState: mapping.state, expectedHead, actualHead: headResult.data.hash, ticketId: info.state.ticket?.id }
     });
+    appendEvent(info.dir, {
+      rev: driftWritten.revision,
+      type: "resumed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: {
+        preCompactState: resumeState,
+        compactionCount: driftWritten.contextPressure?.compactionCount ?? 0,
+        ticketId: info.state.ticket?.id ?? null,
+        headMatch: false,
+        recoveryState: mapping.state
+      }
+    });
+    removeResumeMarker(root);
     const driftPreamble = `**HEAD changed during compaction** (expected ${expectedHead.slice(0, 8)}, got ${headResult.data.hash.slice(0, 8)}). Review state invalidated.
 
 `;
@@ -11586,6 +12306,29 @@ async function handleResume(root, args) {
         reminders: ["Re-implement and verify before re-submitting for code review."]
       });
     }
+    if (mapping.state === "ISSUE_FIX") {
+      const issueFixStage = getStage("ISSUE_FIX");
+      if (issueFixStage) {
+        const recipe = resolveRecipeFromState(driftWritten);
+        const ctx = new StageContext(root, info.dir, driftWritten, recipe);
+        const enterResult = await issueFixStage.enter(ctx);
+        if (isStageAdvance(enterResult)) {
+          return processAdvance(ctx, issueFixStage, enterResult);
+        }
+        return guideResult(ctx.state, "ISSUE_FIX", {
+          instruction: [
+            "# Resumed After Compact \u2014 HEAD Mismatch",
+            "",
+            `${driftPreamble}Recovered to **ISSUE_FIX**. Re-fix the issue and mark resolved.`,
+            "",
+            "---",
+            "",
+            enterResult.instruction
+          ].join("\n"),
+          reminders: enterResult.reminders ?? []
+        });
+      }
+    }
     return guideResult(driftWritten, mapping.state, {
       instruction: `# Resumed After Compact \u2014 HEAD Mismatch
 
@@ -11607,8 +12350,23 @@ ${driftPreamble}Recovered to state: **${mapping.state}**. Continue from here.`,
     compactPreparedAt: null,
     resumeBlocked: false,
     guideCallCount: 0,
-    contextPressure: { ...resumePressure, level: evaluatePressure({ ...info.state, guideCallCount: 0, contextPressure: resumePressure }) }
+    contextPressure: { ...resumePressure, level: evaluatePressure({ ...info.state, guideCallCount: 0, contextPressure: resumePressure }) },
+    // T-184: Update expectedHead on own-commit drift (mergeBase stays at branch-off point)
+    ...ownCommitDrift ? { git: { ...info.state.git, expectedHead: headResult.data.hash } } : {}
+  });
+  appendEvent(info.dir, {
+    rev: written.revision,
+    type: "resumed",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: {
+      preCompactState: resumeState,
+      compactionCount: written.contextPressure?.compactionCount ?? 0,
+      ticketId: info.state.ticket?.id ?? null,
+      headMatch: !ownCommitDrift,
+      ownCommit: ownCommitDrift || void 0
+    }
   });
+  removeResumeMarker(root);
   if (resumeState === "PICK_TICKET") {
     if (isTargetedMode(written)) {
       const dispatched = await dispatchTargetedResume(root, written, info.dir, [
@@ -11722,6 +12480,12 @@ async function handlePreCompact(root, args) {
     await saveSnapshot2(root, loadResult);
   } catch {
   }
+  writeResumeMarker(root, result.sessionId, {
+    ticket: info.state.ticket,
+    completedTickets: info.state.completedTickets,
+    resolvedIssues: info.state.resolvedIssues,
+    preCompactState: result.preCompactState
+  });
   const reread = findSessionById(root, args.sessionId);
   const written = reread?.state ?? info.state;
   return guideResult(written, "COMPACT", {
@@ -11818,276 +12582,96 @@ async function handleCancel(root, args) {
   appendEvent(cancelInfo.dir, {
     rev: written.revision,
     type: "cancelled",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    data: {
-      previousState: cancelInfo.state.state,
-      ticketId: ticketId ?? null,
-      ticketReleased,
-      ticketConflict,
-      stashPopFailed
-    }
-  });
-  const stashNote = stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : "";
-  return {
-    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) and ${(written.resolvedIssues ?? []).length} issue(s) were completed.${stashNote}` }]
-  };
-}
-function guideResult(state, currentState, opts) {
-  const summary = {
-    ticket: state.ticket ? `${state.ticket.id}: ${state.ticket.title}` : "none",
-    risk: state.ticket?.risk ?? "unknown",
-    completed: [...state.completedTickets.map((t) => t.id), ...state.resolvedIssues ?? []],
-    currentStep: currentState,
-    contextPressure: state.contextPressure?.level ?? "low",
-    branch: state.git?.branch ?? null
-  };
-  const allReminders = [...opts.reminders ?? []];
-  if ((state.mode === "auto" || !state.mode) && currentState !== "SESSION_END") {
-    allReminders.push(
-      "NEVER cancel this session due to context size. Compaction is automatic \u2014 Claude Story preserves all session state across compactions via hooks."
-    );
-  }
-  const output = {
-    sessionId: state.sessionId,
-    state: currentState,
-    transitionedFrom: opts.transitionedFrom,
-    instruction: opts.instruction,
-    reminders: allReminders,
-    contextAdvice: "ok",
-    sessionSummary: summary
-  };
-  const parts = [
-    output.instruction,
-    "",
-    "---",
-    `**Session:** ${output.sessionId}`,
-    `**State:** ${output.state}${output.transitionedFrom ? ` (from ${output.transitionedFrom})` : ""}`,
-    `**Ticket:** ${summary.ticket}`,
-    `**Risk:** ${summary.risk}`,
-    `**Completed:** ${summary.completed.length > 0 ? summary.completed.join(", ") : "none"}`,
-    `**Tickets done:** ${summary.completed.length}`,
-    summary.branch ? `**Branch:** ${summary.branch}` : "",
-    output.reminders.length > 0 ? `
-**Reminders:**
-${output.reminders.map((r) => `- ${r}`).join("\n")}` : ""
-  ].filter(Boolean);
-  return { content: [{ type: "text", text: parts.join("\n") }] };
-}
-function guideError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return {
-    content: [{ type: "text", text: `[autonomous_guide error] ${message}` }],
-    isError: true
-  };
-}
-function readFileSafe2(path2) {
-  try {
-    return readFileSync10(path2, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-// src/cli/commands/session-report.ts
-init_esm_shims();
-init_session();
-init_session_types();
-import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
-import { join as join20 } from "path";
-
-// src/core/session-report-formatter.ts
-init_esm_shims();
-function formatSessionReport(data, format) {
-  const { state, events, planContent, gitLog } = data;
-  if (format === "json") {
-    return JSON.stringify({
-      ok: true,
-      data: {
-        summary: buildSummaryData(state),
-        ticketProgression: state.completedTickets,
-        reviewStats: state.reviews,
-        events: events.events.slice(-50),
-        malformedEventCount: events.malformedCount,
-        contextPressure: state.contextPressure,
-        git: {
-          branch: state.git.branch,
-          initHead: state.git.initHead,
-          commits: gitLog
-        },
-        problems: buildProblems(state, events)
-      }
-    }, null, 2);
-  }
-  const sections = [];
-  sections.push(buildSummarySection(state));
-  sections.push(buildTicketSection(state));
-  sections.push(buildReviewSection(state));
-  sections.push(buildEventSection(events));
-  sections.push(buildPressureSection(state));
-  sections.push(buildGitSection(state, gitLog));
-  sections.push(buildProblemsSection(state, events));
-  return sections.join("\n\n---\n\n");
-}
-function buildSummaryData(state) {
-  return {
-    sessionId: state.sessionId,
-    mode: state.mode ?? "auto",
-    recipe: state.recipe,
-    status: state.status,
-    terminationReason: state.terminationReason,
-    startedAt: state.startedAt,
-    lastGuideCall: state.lastGuideCall,
-    guideCallCount: state.guideCallCount,
-    ticketsCompleted: state.completedTickets.length
-  };
-}
-function buildSummarySection(state) {
-  const duration = state.startedAt && state.lastGuideCall ? formatDuration(state.startedAt, state.lastGuideCall) : "unknown";
-  return [
-    "## Session Summary",
-    "",
-    `- **ID:** ${state.sessionId}`,
-    `- **Mode:** ${state.mode ?? "auto"}`,
-    `- **Recipe:** ${state.recipe}`,
-    `- **Status:** ${state.status}${state.terminationReason ? ` (${state.terminationReason})` : ""}`,
-    `- **Duration:** ${duration}`,
-    `- **Guide calls:** ${state.guideCallCount}`,
-    `- **Tickets completed:** ${state.completedTickets.length}`
-  ].join("\n");
-}
-function buildTicketSection(state) {
-  if (state.completedTickets.length === 0) {
-    const current = state.ticket;
-    if (current) {
-      return [
-        "## Ticket Progression",
-        "",
-        `In progress: **${current.id}** \u2014 ${current.title} (risk: ${current.risk ?? "unknown"})`
-      ].join("\n");
-    }
-    return "## Ticket Progression\n\nNo tickets completed.";
-  }
-  const lines = ["## Ticket Progression", ""];
-  for (const t of state.completedTickets) {
-    const risk = t.realizedRisk ? `${t.risk ?? "?"} \u2192 ${t.realizedRisk}` : t.risk ?? "unknown";
-    lines.push(`- **${t.id}:** ${t.title} | risk: ${risk} | commit: \`${t.commitHash ?? "?"}\``);
-  }
-  return lines.join("\n");
-}
-function buildReviewSection(state) {
-  const plan = state.reviews.plan;
-  const code = state.reviews.code;
-  if (plan.length === 0 && code.length === 0) {
-    return "## Review Stats\n\nNo reviews recorded.";
-  }
-  const lines = ["## Review Stats", ""];
-  if (plan.length > 0) {
-    lines.push(`**Plan reviews:** ${plan.length} round(s)`);
-    for (const r of plan) {
-      lines.push(`  - Round ${r.round}: ${r.verdict} (${r.findingCount} findings, ${r.criticalCount} critical, ${r.majorCount} major) \u2014 ${r.reviewer}`);
-    }
-  }
-  if (code.length > 0) {
-    lines.push(`**Code reviews:** ${code.length} round(s)`);
-    for (const r of code) {
-      lines.push(`  - Round ${r.round}: ${r.verdict} (${r.findingCount} findings, ${r.criticalCount} critical, ${r.majorCount} major) \u2014 ${r.reviewer}`);
-    }
-  }
-  const totalFindings = [...plan, ...code].reduce((sum, r) => sum + r.findingCount, 0);
-  lines.push("", `**Total findings:** ${totalFindings}`);
-  return lines.join("\n");
-}
-function buildEventSection(events) {
-  if (events.events.length === 0 && events.malformedCount === 0) {
-    return "## Event Timeline\n\nNot available.";
-  }
-  const capped = events.events.slice(-50);
-  const omitted = events.events.length - capped.length;
-  const lines = ["## Event Timeline", ""];
-  if (omitted > 0) {
-    lines.push(`*${omitted} earlier events omitted*`, "");
-  }
-  for (const e of capped) {
-    const ts = e.timestamp ? e.timestamp.slice(11, 19) : "??:??:??";
-    const detail = e.data ? Object.entries(e.data).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(" ") : "";
-    lines.push(`- \`${ts}\` [${e.type}] ${detail}`.trimEnd());
-  }
-  if (events.malformedCount > 0) {
-    lines.push("", `*${events.malformedCount} malformed event line(s) skipped*`);
-  }
-  return lines.join("\n");
-}
-function buildPressureSection(state) {
-  const p = state.contextPressure;
-  return [
-    "## Context Pressure",
-    "",
-    `- **Level:** ${p.level}`,
-    `- **Guide calls:** ${p.guideCallCount}`,
-    `- **Tickets completed:** ${p.ticketsCompleted}`,
-    `- **Compactions:** ${p.compactionCount}`,
-    `- **Events log:** ${p.eventsLogBytes} bytes`
-  ].join("\n");
-}
-function buildGitSection(state, gitLog) {
-  const lines = [
-    "## Git Summary",
-    "",
-    `- **Branch:** ${state.git.branch ?? "unknown"}`,
-    `- **Init HEAD:** \`${state.git.initHead ?? "?"}\``,
-    `- **Expected HEAD:** \`${state.git.expectedHead ?? "?"}\``
-  ];
-  if (gitLog && gitLog.length > 0) {
-    lines.push("", "**Commits:**");
-    for (const c of gitLog) {
-      lines.push(`- ${c}`);
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: {
+      previousState: cancelInfo.state.state,
+      ticketId: ticketId ?? null,
+      ticketReleased,
+      ticketConflict,
+      stashPopFailed
     }
-  } else {
-    lines.push("", "Commits: Not available.");
+  });
+  removeResumeMarker(root);
+  let reportSection = "";
+  try {
+    const { state: projectState } = await loadProject(root);
+    const nextResult = nextTickets(projectState, 5);
+    const openIssues = projectState.issues.filter((i) => i.status === "open" || i.status === "inprogress").slice(0, 5);
+    const remainingWork = {
+      tickets: nextResult.kind === "found" ? nextResult.candidates.map((c) => ({ id: c.ticket.id, title: c.ticket.title })) : [],
+      issues: openIssues.map((i) => ({ id: i.id, title: i.title, severity: i.severity }))
+    };
+    reportSection = "\n\n" + formatCompactReport({ state: written, endedAt: (/* @__PURE__ */ new Date()).toISOString(), remainingWork });
+  } catch {
   }
-  return lines.join("\n");
+  const stashNote = stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : "";
+  return {
+    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) and ${(written.resolvedIssues ?? []).length} issue(s) were completed.${stashNote}${reportSection}` }]
+  };
 }
-function buildProblems(state, events) {
-  const problems = [];
-  if (state.terminationReason && state.terminationReason !== "normal") {
-    problems.push(`Abnormal termination: ${state.terminationReason}`);
-  }
-  if (events.malformedCount > 0) {
-    problems.push(`${events.malformedCount} malformed event line(s) in events.log`);
-  }
-  for (const e of events.events) {
-    if (e.type.includes("error") || e.type.includes("exhaustion")) {
-      problems.push(`[${e.type}] ${e.timestamp ?? ""} ${JSON.stringify(e.data)}`);
-    } else if (e.data?.result === "exhaustion") {
-      problems.push(`[${e.type}] exhaustion at ${e.timestamp ?? ""}`);
-    }
-  }
-  if (state.deferralsUnfiled) {
-    problems.push("Session has unfiled deferrals");
+function guideResult(state, currentState, opts) {
+  const summary = {
+    ticket: state.ticket ? `${state.ticket.id}: ${state.ticket.title}` : "none",
+    risk: state.ticket?.risk ?? "unknown",
+    completed: [...state.completedTickets.map((t) => t.id), ...state.resolvedIssues ?? []],
+    currentStep: currentState,
+    contextPressure: state.contextPressure?.level ?? "low",
+    branch: state.git?.branch ?? null
+  };
+  const allReminders = [...opts.reminders ?? []];
+  if ((state.mode === "auto" || !state.mode) && currentState !== "SESSION_END") {
+    allReminders.push(
+      "NEVER cancel this session due to context size. Compaction is automatic \u2014 Claude Story preserves all session state across compactions via hooks."
+    );
   }
-  return problems;
+  const output = {
+    sessionId: state.sessionId,
+    state: currentState,
+    transitionedFrom: opts.transitionedFrom,
+    instruction: opts.instruction,
+    reminders: allReminders,
+    contextAdvice: "ok",
+    sessionSummary: summary
+  };
+  const parts = [
+    output.instruction,
+    "",
+    "---",
+    `**Session:** ${output.sessionId}`,
+    `**State:** ${output.state}${output.transitionedFrom ? ` (from ${output.transitionedFrom})` : ""}`,
+    `**Ticket:** ${summary.ticket}`,
+    `**Risk:** ${summary.risk}`,
+    `**Completed:** ${summary.completed.length > 0 ? summary.completed.join(", ") : "none"}`,
+    `**Tickets done:** ${summary.completed.length}`,
+    summary.branch ? `**Branch:** ${summary.branch}` : "",
+    output.reminders.length > 0 ? `
+**Reminders:**
+${output.reminders.map((r) => `- ${r}`).join("\n")}` : ""
+  ].filter(Boolean);
+  return { content: [{ type: "text", text: parts.join("\n") }] };
 }
-function buildProblemsSection(state, events) {
-  const problems = buildProblems(state, events);
-  if (problems.length === 0) {
-    return "## Problems\n\nNone detected.";
-  }
-  return ["## Problems", "", ...problems.map((p) => `- ${p}`)].join("\n");
+function guideError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    content: [{ type: "text", text: `[autonomous_guide error] ${message}` }],
+    isError: true
+  };
 }
-function formatDuration(start, end) {
+function readFileSafe2(path2) {
   try {
-    const ms = new Date(end).getTime() - new Date(start).getTime();
-    if (isNaN(ms) || ms < 0) return "unknown";
-    const mins = Math.floor(ms / 6e4);
-    if (mins < 60) return `${mins}m`;
-    const hours = Math.floor(mins / 60);
-    return `${hours}h ${mins % 60}m`;
+    return readFileSync10(path2, "utf-8");
   } catch {
-    return "unknown";
+    return "";
   }
 }
 
 // src/cli/commands/session-report.ts
+init_esm_shims();
+init_session();
+init_session_types();
+init_git_inspector();
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import { join as join21 } from "path";
 var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function handleSessionReport(sessionId, root, format = "md") {
   if (!UUID_REGEX.test(sessionId)) {
@@ -12099,7 +12683,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
     };
   }
   const dir = sessionDir(root, sessionId);
-  if (!existsSync12(dir)) {
+  if (!existsSync13(dir)) {
     return {
       output: `Error: Session ${sessionId} not found.`,
       exitCode: 1,
@@ -12107,8 +12691,8 @@ async function handleSessionReport(sessionId, root, format = "md") {
       isError: true
     };
   }
-  const statePath2 = join20(dir, "state.json");
-  if (!existsSync12(statePath2)) {
+  const statePath2 = join21(dir, "state.json");
+  if (!existsSync13(statePath2)) {
     return {
       output: `Error: Session ${sessionId} corrupt \u2014 state.json missing.`,
       exitCode: 1,
@@ -12146,7 +12730,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
   const events = readEvents(dir);
   let planContent = null;
   try {
-    planContent = readFileSync11(join20(dir, "plan.md"), "utf-8");
+    planContent = readFileSync11(join21(dir, "plan.md"), "utf-8");
   } catch {
   }
   let gitLog = null;
@@ -12171,7 +12755,7 @@ init_issue();
 init_roadmap();
 init_output_formatter();
 init_helpers();
-import { join as join21, resolve as resolve7 } from "path";
+import { join as join22, resolve as resolve7 } from "path";
 var PHASE_ID_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var PHASE_ID_MAX_LENGTH = 40;
 function validatePhaseId(id) {
@@ -12280,7 +12864,7 @@ function formatMcpError(code, message) {
 async function runMcpReadTool(pinnedRoot, handler) {
   try {
     const { state, warnings } = await loadProject(pinnedRoot);
-    const handoversDir = join22(pinnedRoot, ".story", "handovers");
+    const handoversDir = join23(pinnedRoot, ".story", "handovers");
     const ctx = { state, warnings, root: pinnedRoot, handoversDir, format: "md" };
     const result = await handler(ctx);
     if (result.errorCode && INFRASTRUCTURE_ERROR_CODES.includes(result.errorCode)) {
@@ -12828,6 +13412,7 @@ function registerAllTools(server, pinnedRoot) {
           disposition: z10.string()
         })).optional().describe("Review findings"),
         reviewerSessionId: z10.string().optional().describe("Codex session ID"),
+        reviewer: z10.string().optional().describe("Actual reviewer backend used (e.g. 'agent' when codex was unavailable)"),
         notes: z10.string().optional().describe("Free-text notes")
       }).optional().describe("Report data (required for report action)")
     }
@@ -12852,7 +13437,7 @@ function registerAllTools(server, pinnedRoot) {
     }
   });
   server.registerTool("claudestory_review_lenses_synthesize", {
-    description: "Synthesize lens results after parallel review. Validates findings, applies blocking policy, generates merger prompt. Call after collecting all lens subagent results.",
+    description: "Synthesize lens results after parallel review. Validates findings, applies blocking policy, classifies origin (introduced vs pre-existing), auto-files pre-existing issues, generates merger prompt. Call after collecting all lens subagent results.",
     inputSchema: {
       stage: z10.enum(["CODE_REVIEW", "PLAN_REVIEW"]).optional().describe("Review stage (defaults to CODE_REVIEW)"),
       lensResults: z10.array(z10.object({
@@ -12863,9 +13448,13 @@ function registerAllTools(server, pinnedRoot) {
       activeLenses: z10.array(z10.string()).describe("Active lens names from prepare step"),
       skippedLenses: z10.array(z10.string()).describe("Skipped lens names from prepare step"),
       reviewRound: z10.number().int().min(1).optional().describe("Current review round"),
-      reviewId: z10.string().optional().describe("Review ID from prepare step")
+      reviewId: z10.string().optional().describe("Review ID from prepare step"),
+      // T-192: Origin classification inputs
+      diff: z10.string().optional().describe("The diff being reviewed (for origin classification of findings into introduced vs pre-existing)"),
+      changedFiles: z10.array(z10.string()).optional().describe("Changed file paths from prepare step (for origin classification)"),
+      sessionId: z10.string().uuid().optional().describe("Active session ID (for dedup of auto-filed pre-existing issues across review rounds)")
     }
-  }, (args) => {
+  }, async (args) => {
     try {
       const result = handleSynthesize({
         stage: args.stage,
@@ -12876,9 +13465,55 @@ function registerAllTools(server, pinnedRoot) {
           reviewRound: args.reviewRound ?? 1,
           reviewId: args.reviewId ?? "unknown"
         },
-        projectRoot: pinnedRoot
+        projectRoot: pinnedRoot,
+        diff: args.diff,
+        changedFiles: args.changedFiles
       });
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      const filedIssues = [];
+      if (result.preExistingFindings.length > 0) {
+        const sessionDir2 = args.sessionId ? join23(pinnedRoot, ".story", "sessions", args.sessionId) : null;
+        const alreadyFiled = sessionDir2 ? readFiledPreexisting(sessionDir2) : /* @__PURE__ */ new Set();
+        const sizeBeforeLoop = alreadyFiled.size;
+        for (const f of result.preExistingFindings) {
+          const dedupKey = f.issueKey ?? `${f.file ?? ""}:${f.line ?? 0}:${f.category}`;
+          if (alreadyFiled.has(dedupKey)) continue;
+          try {
+            const { handleIssueCreate: handleIssueCreate2 } = await Promise.resolve().then(() => (init_issue2(), issue_exports));
+            const severityMap = { critical: "critical", major: "high", minor: "medium" };
+            const severity = severityMap[f.severity] ?? "medium";
+            const issueResult = await handleIssueCreate2(
+              {
+                title: `[pre-existing] [${f.category}] ${f.description.slice(0, 60)}`,
+                severity,
+                impact: f.description,
+                components: ["review-lenses"],
+                relatedTickets: [],
+                location: f.file && f.line != null ? [`${f.file}:${f.line}`] : []
+              },
+              "json",
+              pinnedRoot
+            );
+            let issueId;
+            try {
+              const parsed = JSON.parse(issueResult.output ?? "");
+              issueId = parsed?.data?.id;
+            } catch {
+              const match = issueResult.output?.match(/ISS-\d+/);
+              issueId = match?.[0];
+            }
+            if (issueId) {
+              filedIssues.push({ issueKey: dedupKey, issueId });
+              alreadyFiled.add(dedupKey);
+            }
+          } catch {
+          }
+        }
+        if (sessionDir2 && alreadyFiled.size > sizeBeforeLoop) {
+          writeFiledPreexisting(sessionDir2, alreadyFiled);
+        }
+      }
+      const output = { ...result, filedIssues };
+      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
     } catch (err) {
       const msg = err instanceof Error ? err.message.replace(/\/[^\s]+/g, "<path>") : "unknown error";
       return { content: [{ type: "text", text: `Error synthesizing lens results: ${msg}` }], isError: true };
@@ -12919,16 +13554,33 @@ function registerAllTools(server, pinnedRoot) {
     }
   });
 }
+var FILED_PREEXISTING_FILE = "filed-preexisting.json";
+function readFiledPreexisting(sessionDir2) {
+  try {
+    const raw = readFileSync12(join23(sessionDir2, FILED_PREEXISTING_FILE), "utf-8");
+    const arr = JSON.parse(raw);
+    return new Set(Array.isArray(arr) ? arr : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeFiledPreexisting(sessionDir2, keys) {
+  try {
+    mkdirSync5(sessionDir2, { recursive: true });
+    writeFileSync7(join23(sessionDir2, FILED_PREEXISTING_FILE), JSON.stringify([...keys], null, 2));
+  } catch {
+  }
+}
 
 // src/core/init.ts
 init_esm_shims();
 init_project_loader();
 init_errors();
 import { mkdir as mkdir4, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join23, resolve as resolve8 } from "path";
+import { join as join24, resolve as resolve8 } from "path";
 async function initProject(root, options) {
   const absRoot = resolve8(root);
-  const wrapDir = join23(absRoot, ".story");
+  const wrapDir = join24(absRoot, ".story");
   let exists = false;
   try {
     const s = await stat2(wrapDir);
@@ -12948,11 +13600,11 @@ async function initProject(root, options) {
       ".story/ already exists. Use --force to overwrite config and roadmap."
     );
   }
-  await mkdir4(join23(wrapDir, "tickets"), { recursive: true });
-  await mkdir4(join23(wrapDir, "issues"), { recursive: true });
-  await mkdir4(join23(wrapDir, "handovers"), { recursive: true });
-  await mkdir4(join23(wrapDir, "notes"), { recursive: true });
-  await mkdir4(join23(wrapDir, "lessons"), { recursive: true });
+  await mkdir4(join24(wrapDir, "tickets"), { recursive: true });
+  await mkdir4(join24(wrapDir, "issues"), { recursive: true });
+  await mkdir4(join24(wrapDir, "handovers"), { recursive: true });
+  await mkdir4(join24(wrapDir, "notes"), { recursive: true });
+  await mkdir4(join24(wrapDir, "lessons"), { recursive: true });
   const created = [
     ".story/config.json",
     ".story/roadmap.json",
@@ -12992,7 +13644,7 @@ async function initProject(root, options) {
   };
   await writeConfig(config, absRoot);
   await writeRoadmap(roadmap, absRoot);
-  const gitignorePath = join23(wrapDir, ".gitignore");
+  const gitignorePath = join24(wrapDir, ".gitignore");
   await ensureGitignoreEntries(gitignorePath, STORY_GITIGNORE_ENTRIES);
   const warnings = [];
   if (options.force && exists) {
@@ -13028,10 +13680,393 @@ async function ensureGitignoreEntries(gitignorePath, entries) {
   await writeFile2(gitignorePath, content, "utf-8");
 }
 
+// src/channel/inbox-watcher.ts
+init_esm_shims();
+import { watch } from "fs";
+import { readdir as readdir4, readFile as readFile5, unlink as unlink3, rename as rename2, mkdir as mkdir5 } from "fs/promises";
+import { join as join25 } from "path";
+
+// src/channel/events.ts
+init_esm_shims();
+import { z as z11 } from "zod";
+var TicketRequestedPayload = z11.object({
+  ticketId: z11.string().regex(/^T-\d+[a-z]?$/)
+});
+var PauseSessionPayload = z11.object({});
+var ResumeSessionPayload = z11.object({});
+var CancelSessionPayload = z11.object({
+  reason: z11.string().max(1e3).optional()
+});
+var PriorityChangedPayload = z11.object({
+  ticketId: z11.string().regex(/^T-\d+[a-z]?$/),
+  newOrder: z11.number().int()
+});
+var PermissionResponsePayload = z11.object({
+  requestId: z11.string().regex(/^[a-zA-Z0-9]{5}$/),
+  behavior: z11.enum(["approve", "deny"])
+});
+var ChannelEventSchema = z11.discriminatedUnion("event", [
+  z11.object({
+    event: z11.literal("ticket_requested"),
+    timestamp: z11.string(),
+    payload: TicketRequestedPayload
+  }),
+  z11.object({
+    event: z11.literal("pause_session"),
+    timestamp: z11.string(),
+    payload: PauseSessionPayload
+  }),
+  z11.object({
+    event: z11.literal("resume_session"),
+    timestamp: z11.string(),
+    payload: ResumeSessionPayload
+  }),
+  z11.object({
+    event: z11.literal("cancel_session"),
+    timestamp: z11.string(),
+    payload: CancelSessionPayload
+  }),
+  z11.object({
+    event: z11.literal("priority_changed"),
+    timestamp: z11.string(),
+    payload: PriorityChangedPayload
+  }),
+  z11.object({
+    event: z11.literal("permission_response"),
+    timestamp: z11.string(),
+    payload: PermissionResponsePayload
+  })
+]);
+var VALID_FILENAME = /^[\d]{4}-[\d]{2}-[\d]{2}T[\w.:-]+-[\w]+\.json$/;
+function isValidInboxFilename(filename) {
+  if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
+    return false;
+  }
+  return VALID_FILENAME.test(filename);
+}
+function formatChannelContent(event) {
+  switch (event.event) {
+    case "ticket_requested":
+      return `User requested ticket ${event.payload.ticketId} be started.`;
+    case "pause_session":
+      return "User requested the autonomous session be paused.";
+    case "resume_session":
+      return "User requested the autonomous session be resumed.";
+    case "cancel_session": {
+      const reason = event.payload.reason ? ` Reason: ${event.payload.reason}` : "";
+      return `User requested the autonomous session be cancelled.${reason}`;
+    }
+    case "priority_changed":
+      return `User changed priority of ticket ${event.payload.ticketId} to order ${event.payload.newOrder}.`;
+    case "permission_response":
+      return `Permission response for request ${event.payload.requestId}: ${event.payload.behavior}.`;
+  }
+}
+function formatChannelMeta(event) {
+  const meta = { event: event.event };
+  switch (event.event) {
+    case "ticket_requested":
+      meta.ticketId = event.payload.ticketId;
+      break;
+    case "cancel_session":
+      if (event.payload.reason) meta.reason = event.payload.reason;
+      break;
+    case "priority_changed":
+      meta.ticketId = event.payload.ticketId;
+      meta.newOrder = String(event.payload.newOrder);
+      break;
+    case "permission_response":
+      meta.requestId = event.payload.requestId;
+      meta.behavior = event.payload.behavior;
+      break;
+  }
+  return meta;
+}
+
+// src/channel/inbox-watcher.ts
+var INBOX_DIR = "channel-inbox";
+var FAILED_DIR = ".failed";
+var MAX_INBOX_DEPTH = 50;
+var MAX_FAILED_FILES = 20;
+var DEBOUNCE_MS = 100;
+var MAX_PERMISSION_RETRIES = 15;
+var MAX_EVENT_RETRIES = 30;
+var EVENT_EXPIRY_MS = 6e4;
+var watcher = null;
+var permissionRetryCount = /* @__PURE__ */ new Map();
+var eventRetryCount = /* @__PURE__ */ new Map();
+var debounceTimer = null;
+async function startInboxWatcher(root, server) {
+  const inboxPath = join25(root, ".story", INBOX_DIR);
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    permissionRetryCount.clear();
+  }
+  await mkdir5(inboxPath, { recursive: true });
+  await recoverStaleProcessingFiles(inboxPath);
+  await processInbox(inboxPath, server);
+  try {
+    watcher = watch(inboxPath, (eventType) => {
+      if (eventType === "rename") {
+        scheduleDebouncedProcess(inboxPath, server);
+      }
+    });
+    watcher.on("error", (err) => {
+      process.stderr.write(`claudestory: channel inbox watcher error: ${err.message}
+`);
+      startPollingFallback(inboxPath, server);
+    });
+    process.stderr.write(`claudestory: channel inbox watcher started at ${inboxPath}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`claudestory: failed to start inbox watcher, using polling fallback: ${msg}
+`);
+    startPollingFallback(inboxPath, server);
+  }
+}
+function stopInboxWatcher() {
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+  }
+  if (pollInterval) {
+    clearInterval(pollInterval);
+    pollInterval = null;
+  }
+  permissionRetryCount.clear();
+}
+function scheduleDebouncedProcess(inboxPath, server) {
+  if (debounceTimer) clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    debounceTimer = null;
+    processInbox(inboxPath, server).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`claudestory: inbox processing error: ${msg}
+`);
+    });
+  }, DEBOUNCE_MS);
+}
+var pollInterval = null;
+function startPollingFallback(inboxPath, server) {
+  if (pollInterval) return;
+  pollInterval = setInterval(() => {
+    processInbox(inboxPath, server).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`claudestory: poll processing error: ${msg}
+`);
+    });
+  }, 2e3);
+}
+async function recoverStaleProcessingFiles(inboxPath) {
+  let entries;
+  try {
+    entries = await readdir4(inboxPath);
+  } catch {
+    return;
+  }
+  for (const f of entries) {
+    if (f.endsWith(".processing")) {
+      const originalName = f.slice(0, -".processing".length);
+      try {
+        await rename2(join25(inboxPath, f), join25(inboxPath, originalName));
+        process.stderr.write(`claudestory: recovered stale processing file: ${f}
+`);
+      } catch {
+      }
+    }
+  }
+}
+async function processInbox(inboxPath, server) {
+  while (true) {
+    let entries;
+    try {
+      entries = await readdir4(inboxPath);
+    } catch {
+      return;
+    }
+    const eventFiles = entries.filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
+    if (eventFiles.length === 0) break;
+    const batch = eventFiles.slice(0, MAX_INBOX_DEPTH);
+    if (eventFiles.length > MAX_INBOX_DEPTH) {
+      process.stderr.write(
+        `claudestory: channel inbox has ${eventFiles.length} files, processing batch of ${MAX_INBOX_DEPTH}
+`
+      );
+    }
+    for (const filename of batch) {
+      await processEventFile(inboxPath, filename, server);
+    }
+    if (eventFiles.length <= MAX_INBOX_DEPTH) break;
+  }
+  await trimFailedDirectory(inboxPath);
+}
+async function processEventFile(inboxPath, filename, server) {
+  if (!isValidInboxFilename(filename)) {
+    process.stderr.write(`claudestory: rejecting invalid inbox filename: ${filename}
+`);
+    await moveToFailed(inboxPath, filename);
+    return;
+  }
+  const filePath = join25(inboxPath, filename);
+  const processingPath = join25(inboxPath, `${filename}.processing`);
+  try {
+    await rename2(filePath, processingPath);
+  } catch {
+    return;
+  }
+  let raw;
+  try {
+    raw = await readFile5(processingPath, "utf-8");
+  } catch {
+    await moveToFailed(inboxPath, `${filename}.processing`, filename);
+    return;
+  }
+  const processingFilename = `${filename}.processing`;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    process.stderr.write(`claudestory: invalid JSON in channel event ${filename}
+`);
+    await moveToFailed(inboxPath, processingFilename, filename);
+    return;
+  }
+  const result = ChannelEventSchema.safeParse(parsed);
+  if (!result.success) {
+    process.stderr.write(`claudestory: invalid channel event schema in ${filename}: ${result.error.message}
+`);
+    await moveToFailed(inboxPath, processingFilename, filename);
+    return;
+  }
+  const event = result.data;
+  try {
+    if (event.event === "permission_response") {
+      await server.server.sendNotification({
+        method: "notifications/claude/channel/permission",
+        params: {
+          requestId: event.payload.requestId,
+          behavior: event.payload.behavior
+        }
+      });
+    } else {
+      const content = formatChannelContent(event);
+      const meta = formatChannelMeta(event);
+      await server.server.sendNotification({
+        method: "notifications/claude/channel",
+        params: { content, meta }
+      });
+    }
+    process.stderr.write(`claudestory: sent channel event ${event.event}
+`);
+    permissionRetryCount.delete(filename);
+    eventRetryCount.delete(filename);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (event.event === "permission_response") {
+      const retries2 = (permissionRetryCount.get(filename) ?? 0) + 1;
+      permissionRetryCount.set(filename, retries2);
+      if (retries2 >= MAX_PERMISSION_RETRIES) {
+        process.stderr.write(`claudestory: permission notification failed after ${retries2} retries, quarantining: ${msg}
+`);
+        permissionRetryCount.delete(filename);
+        await moveToFailed(inboxPath, processingFilename, filename);
+        return;
+      }
+      try {
+        await rename2(processingPath, filePath);
+      } catch (renameErr) {
+        const renameMsg = renameErr instanceof Error ? renameErr.message : String(renameErr);
+        process.stderr.write(`claudestory: rename-back failed for ${filename}, quarantining: ${renameMsg}
+`);
+        permissionRetryCount.delete(filename);
+        await moveToFailed(inboxPath, processingFilename, filename);
+        return;
+      }
+      process.stderr.write(`claudestory: permission notification failed (attempt ${retries2}/${MAX_PERMISSION_RETRIES}), keeping for retry: ${msg}
+`);
+      return;
+    }
+    const eventAge = Date.now() - new Date(event.timestamp).getTime();
+    if (eventAge > EVENT_EXPIRY_MS) {
+      process.stderr.write(`claudestory: channel event ${event.event} expired after ${Math.round(eventAge / 1e3)}s, quarantining: ${msg}
+`);
+      eventRetryCount.delete(filename);
+      await moveToFailed(inboxPath, processingFilename, filename);
+      return;
+    }
+    const retries = (eventRetryCount.get(filename) ?? 0) + 1;
+    eventRetryCount.set(filename, retries);
+    if (retries >= MAX_EVENT_RETRIES) {
+      process.stderr.write(`claudestory: channel event ${event.event} failed after ${retries} retries, quarantining: ${msg}
+`);
+      eventRetryCount.delete(filename);
+      await moveToFailed(inboxPath, processingFilename, filename);
+      return;
+    }
+    try {
+      await rename2(processingPath, filePath);
+    } catch (renameErr) {
+      const renameMsg = renameErr instanceof Error ? renameErr.message : String(renameErr);
+      process.stderr.write(`claudestory: rename-back failed for ${filename}, quarantining: ${renameMsg}
+`);
+      eventRetryCount.delete(filename);
+      await moveToFailed(inboxPath, processingFilename, filename);
+      return;
+    }
+    process.stderr.write(`claudestory: channel event ${event.event} failed (attempt ${retries}/${MAX_EVENT_RETRIES}), keeping for retry: ${msg}
+`);
+    return;
+  }
+  try {
+    await unlink3(processingPath);
+  } catch {
+  }
+}
+async function moveToFailed(inboxPath, sourceFilename, destFilename) {
+  const failedDir = join25(inboxPath, FAILED_DIR);
+  const targetName = destFilename ?? sourceFilename;
+  try {
+    await mkdir5(failedDir, { recursive: true });
+    await rename2(join25(inboxPath, sourceFilename), join25(failedDir, targetName));
+  } catch (err) {
+    try {
+      await unlink3(join25(inboxPath, sourceFilename));
+    } catch {
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`claudestory: failed to move ${sourceFilename} to .failed/: ${msg}
+`);
+  }
+}
+async function trimFailedDirectory(inboxPath) {
+  const failedDir = join25(inboxPath, FAILED_DIR);
+  let files;
+  try {
+    files = await readdir4(failedDir);
+  } catch {
+    return;
+  }
+  const sorted = files.filter((f) => f.endsWith(".json")).sort();
+  if (sorted.length <= MAX_FAILED_FILES) return;
+  const toDelete = sorted.slice(0, sorted.length - MAX_FAILED_FILES);
+  for (const f of toDelete) {
+    try {
+      await unlink3(join25(failedDir, f));
+    } catch {
+    }
+  }
+}
+
 // src/mcp/index.ts
 var ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
 var CONFIG_PATH2 = ".story/config.json";
-var version = "0.1.61";
+var version = "0.1.63";
 function tryDiscoverRoot() {
   const envRoot = process.env[ENV_VAR2];
   if (envRoot) {
@@ -13043,7 +14078,7 @@ function tryDiscoverRoot() {
     const resolved = resolve9(envRoot);
     try {
       const canonical = realpathSync3(resolved);
-      if (existsSync13(join24(canonical, CONFIG_PATH2))) {
+      if (existsSync14(join26(canonical, CONFIG_PATH2))) {
         return canonical;
       }
       process.stderr.write(`Warning: No .story/config.json at ${canonical}
@@ -13071,9 +14106,9 @@ function registerDegradedTools(server) {
   const degradedInit = server.registerTool("claudestory_init", {
     description: "Initialize a new .story/ project in the current directory",
     inputSchema: {
-      name: z11.string().describe("Project name"),
-      type: z11.string().optional().describe("Project type (e.g. npm, macapp, cargo, generic)"),
-      language: z11.string().optional().describe("Primary language (e.g. typescript, swift, rust)")
+      name: z12.string().describe("Project name"),
+      type: z12.string().optional().describe("Project type (e.g. npm, macapp, cargo, generic)"),
+      language: z12.string().optional().describe("Primary language (e.g. typescript, swift, rust)")
     }
   }, async (args) => {
     let result;
@@ -13103,6 +14138,12 @@ function registerDegradedTools(server) {
       return { content: [{ type: "text", text: `Initialized .story/ project "${args.name}" at ${result.root}
 
 Warning: tool registration failed. Restart the MCP server for full tool access.` }] };
+    }
+    try {
+      await startInboxWatcher(result.root, server);
+    } catch (watchErr) {
+      process.stderr.write(`claudestory: inbox watcher failed after init: ${watchErr instanceof Error ? watchErr.message : String(watchErr)}
+`);
     }
     process.stderr.write(`claudestory: initialized at ${result.root}
 `);
@@ -13122,17 +14163,32 @@ async function main() {
   const server = new McpServer(
     { name: "claudestory", version },
     {
-      instructions: root ? "Start with claudestory_status for a project overview, then claudestory_ticket_next for the highest-priority work, then claudestory_handover_latest for session context." : "No .story/ project found. Use claudestory_init to initialize a new project, or navigate to a directory with .story/."
+      instructions: root ? "Start with claudestory_status for a project overview, then claudestory_ticket_next for the highest-priority work, then claudestory_handover_latest for session context." : "No .story/ project found. Use claudestory_init to initialize a new project, or navigate to a directory with .story/.",
+      capabilities: {
+        experimental: {
+          "claude/channel": {},
+          "claude/channel/permission": {}
+        }
+      }
     }
   );
   if (root) {
     registerAllTools(server, root);
+    await startInboxWatcher(root, server);
     process.stderr.write(`claudestory MCP server running (root: ${root})
 `);
   } else {
     registerDegradedTools(server);
     process.stderr.write("claudestory MCP server running (no project \u2014 claudestory_init available)\n");
   }
+  process.on("SIGINT", () => {
+    stopInboxWatcher();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stopInboxWatcher();
+    process.exit(0);
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }