@anthropologies/claudestory 0.1.62 → 0.1.63

package/dist/cli.js

@@ -221,8 +221,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
@@ -284,6 +288,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(),
@@ -1831,6 +1839,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 });
@@ -2609,6 +2620,63 @@ var init_orchestrator = __esm({
   }
 });
 
+// src/autonomous/review-lenses/diff-scope.ts
+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";
+}
+var init_diff_scope = __esm({
+  "src/autonomous/review-lenses/diff-scope.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/autonomous/review-lenses/mcp-handlers.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join6 } from "path";
@@ -2707,6 +2775,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 = [];
@@ -2739,7 +2808,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);
       }
@@ -2754,6 +2824,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 {
@@ -2763,7 +2836,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) {
@@ -2788,8 +2863,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
@@ -2816,6 +2891,7 @@ var init_mcp_handlers = __esm({
     init_schema_validator();
     init_issue_key();
     init_blocking_policy();
+    init_diff_scope();
     init_merger();
     init_judge();
     init_types();
@@ -3094,12 +3170,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;
@@ -3180,19 +3257,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);
           }
         }
@@ -3209,6 +3286,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) {
@@ -4525,7 +4603,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,
@@ -4547,7 +4625,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}`,
@@ -4996,7 +5074,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("");
@@ -5004,6 +5082,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) {
@@ -5265,7 +5350,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("");
@@ -6633,6 +6718,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, {
@@ -6672,6 +6955,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");
@@ -6867,7 +7154,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(
@@ -6897,6 +7184,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,
@@ -6905,7 +7216,8 @@ function buildRecap(currentState, snapshotInfo) {
       highSeverityIssues,
       recentlyClearedBlockers
     },
-    partial: (snapshot.warnings ?? []).length > 0
+    partial: (snapshot.warnings ?? []).length > 0,
+    ...staleness ? { staleness } : {}
   };
 }
 function formatSnapshotFilename(date) {
@@ -6952,6 +7264,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(),
@@ -6968,7 +7281,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;
   }
@@ -6977,7 +7291,7 @@ var init_snapshot = __esm({
 // src/cli/commands/recap.ts
 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) };
 }
 var init_recap = __esm({
@@ -8407,15 +8721,17 @@ var init_state_machine = __esm({
       // 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"],
@@ -8494,16 +8810,24 @@ 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];
+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];
 }
-var SENSITIVE_PATTERNS;
+var SENSITIVE_PATTERNS, CODEX_CACHE_TTL_MS;
 var init_review_depth = __esm({
   "src/autonomous/review-depth.ts"() {
     "use strict";
@@ -8516,173 +8840,22 @@ var init_review_depth = __esm({
       /\bmiddleware\b/i,
       /\.env/i
     ];
+    CODEX_CACHE_TTL_MS = 10 * 60 * 1e3;
   }
 });
 
-// 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 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 };
-}
-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/autonomous/recipes/loader.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join14, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-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);
+// src/autonomous/recipes/loader.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join14, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+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;
@@ -8736,6 +8909,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 = {
@@ -9072,7 +9252,15 @@ var init_pick_ticket = __esm({
     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) {
@@ -9172,7 +9360,12 @@ var init_pick_ticket = __esm({
         }
         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.` };
@@ -9194,7 +9387,8 @@ var init_pick_ticket = __esm({
         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",
@@ -9225,7 +9419,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.` };
@@ -9234,11 +9433,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,
@@ -9394,7 +9598,7 @@ var init_plan_review = __esm({
         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") {
@@ -9405,10 +9609,11 @@ var init_plan_review = __esm({
               "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",
@@ -9435,7 +9640,11 @@ var init_plan_review = __esm({
             `{ "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
         };
       }
@@ -9448,7 +9657,8 @@ var init_plan_review = __esm({
         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,
@@ -9460,6 +9670,9 @@ var init_plan_review = __esm({
           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(
@@ -9547,7 +9760,7 @@ var init_plan_review = __esm({
           }
           return { action: "advance" };
         }
-        const nextReviewerName = nextReviewer(planReviews, backends);
+        const nextReviewerName = nextReviewer(planReviews, backends, ctx.state.codexUnavailable, ctx.state.codexUnavailableSince);
         return {
           action: "retry",
           instruction: [
@@ -9697,7 +9910,7 @@ var init_write_tests = __esm({
         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;
@@ -9874,26 +10087,29 @@ var init_code_review = __esm({
         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"),
@@ -9901,14 +10117,14 @@ var init_code_review = __esm({
               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}`,
             "",
@@ -9920,7 +10136,8 @@ var init_code_review = __esm({
           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
         };
@@ -9934,7 +10151,8 @@ var init_code_review = __esm({
         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,
@@ -9946,6 +10164,9 @@ var init_code_review = __esm({
           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(
@@ -9970,6 +10191,7 @@ var init_code_review = __esm({
         } else {
           nextAction = "CODE_REVIEW";
         }
+        const isIssueFix = !!ctx.state.currentIssue;
         if (nextAction === "PLAN") {
           clearCache(ctx.dir);
           ctx.writeState({
@@ -9981,9 +10203,12 @@ var init_code_review = __esm({
             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 = {
@@ -10006,6 +10231,9 @@ var init_code_review = __esm({
         });
         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") {
@@ -10032,7 +10260,7 @@ var init_code_review = __esm({
           }
           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",
@@ -10336,16 +10564,49 @@ var init_finalize = __esm({
     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."
@@ -10366,6 +10627,9 @@ var init_finalize = __esm({
           return this.handlePrecommit(ctx);
         }
         if (action === "commit_done") {
+          if (!checkpoint) {
+            ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
+          }
           return this.handleCommit(ctx, report);
         }
         return {
@@ -10379,12 +10643,12 @@ var init_finalize = __esm({
           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);
@@ -10419,15 +10683,14 @@ var init_finalize = __esm({
           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",
@@ -10457,17 +10720,17 @@ var init_finalize = __esm({
           }
         }
         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) {
@@ -10484,8 +10747,9 @@ var init_finalize = __esm({
           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 });
@@ -10556,6 +10820,7 @@ var init_finalize = __esm({
             finalizeCheckpoint: "committed",
             resolvedIssues: [...ctx.state.resolvedIssues ?? [], currentIssue.id],
             currentIssue: null,
+            ticketStartedAt: null,
             git: {
               ...ctx.state.git,
               mergeBase: normalizedHash,
@@ -10565,11 +10830,20 @@ var init_finalize = __esm({
           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,
@@ -10612,7 +10886,7 @@ var init_complete = __esm({
             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.`,
                 "",
@@ -10623,36 +10897,23 @@ var init_complete = __esm({
             }
           };
         }
-        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) {
@@ -10667,66 +10928,118 @@ var init_complete = __esm({
           }
         }
         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"
-            }
-          };
-        }
-        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: 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"
+              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"
+          }
+        };
+      }
+      // ---------------------------------------------------------------------------
+      // Standard auto PICK_TICKET instruction
+      // ---------------------------------------------------------------------------
+      buildStandardPickResult(ctx, projectState, ticketsDone, maxTickets) {
         const candidates = nextTickets(projectState, 5);
         let candidatesText = "";
         if (candidates.kind === "found") {
@@ -10740,7 +11053,7 @@ var init_complete = __esm({
           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.",
               "",
@@ -10754,16 +11067,13 @@ var init_complete = __esm({
             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);
-      }
     };
   }
 });
@@ -10891,7 +11201,32 @@ var init_issue_fix = __esm({
         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}`,
@@ -10926,7 +11261,12 @@ var init_issue_fix = __esm({
         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 {
@@ -10935,6 +11275,10 @@ var init_issue_fix = __esm({
             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",
@@ -10944,9 +11288,10 @@ var init_issue_fix = __esm({
               "",
               `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"
@@ -10970,7 +11315,12 @@ var init_issue_sweep = __esm({
         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" };
@@ -11022,7 +11372,12 @@ var init_issue_sweep = __esm({
         }
         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 {
@@ -11041,7 +11396,16 @@ var init_issue_sweep = __esm({
             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",
@@ -11064,204 +11428,511 @@ Impact: ${nextIssue.impact}` : ""}` : `Fix issue ${next}.`,
   }
 });
 
-// src/autonomous/stages/handover.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+// src/autonomous/resume-marker.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, existsSync as existsSync11 } from "fs";
 import { join as join17 } from "path";
-var HandoverStage;
-var init_handover2 = __esm({
-  "src/autonomous/stages/handover.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_handover();
-    init_git_inspector();
-    HandoverStage = class {
-      id = "HANDOVER";
-      async enter(ctx) {
-        const ticketsDone = ctx.state.completedTickets.length;
-        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
-        return {
-          instruction: [
-            `# Session Complete \u2014 ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`,
-            "",
-            "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: [
-            "Before recording a new lesson, call claudestory_lesson_list to check existing lessons. Then choose: create (new insight), reinforce (existing lesson confirmed), update (refine wording), or skip."
-          ],
-          transitionedFrom: ctx.state.previousState ?? void 0
-        };
-      }
-      async report(ctx, report) {
-        const content = report.handoverContent;
-        if (!content) {
-          return { action: "retry", instruction: "Missing handoverContent. Write the handover and include it in the report." };
-        }
-        let handoverFailed = false;
-        try {
-          await handleHandoverCreate(content, "auto-session", "md", ctx.root);
-        } catch {
-          handoverFailed = true;
-          try {
-            const fallbackPath = join17(ctx.dir, "handover-fallback.md");
-            writeFileSync4(fallbackPath, content, "utf-8");
-          } catch {
-          }
-        }
-        let stashPopFailed = false;
-        const autoStash = ctx.state.git.autoStash;
-        if (autoStash) {
-          const popResult = await gitStashPop(ctx.root, autoStash.ref);
-          if (!popResult.ok) {
-            stashPopFailed = true;
-          }
-        }
-        await ctx.drainDeferrals();
-        const hasUnfiled = (ctx.state.pendingDeferrals ?? []).length > 0;
-        ctx.writeState({
-          state: "SESSION_END",
-          previousState: "HANDOVER",
-          status: "completed",
-          terminationReason: "normal",
-          deferralsUnfiled: hasUnfiled
-        });
-        ctx.appendEvent("session_end", {
-          ticketsCompleted: ctx.state.completedTickets.length,
-          issuesResolved: (ctx.state.resolvedIssues ?? []).length,
-          handoverFailed
-        });
-        const ticketsDone = ctx.state.completedTickets.length;
-        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
-        const resolvedList = (ctx.state.resolvedIssues ?? []).map((id) => `- ${id} (resolved)`).join("\n");
-        return {
-          action: "advance",
-          result: {
-            instruction: [
-              "# Session Complete",
-              "",
-              `${ticketsDone} ticket(s) and ${issuesDone} issue(s) completed.${handoverFailed ? " Handover creation failed \u2014 fallback saved to session directory." : " Handover written."}${stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : ""} Session ended.`,
-              "",
-              ctx.state.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n"),
-              ...resolvedList ? [resolvedList] : []
-            ].join("\n"),
-            reminders: [],
-            transitionedFrom: "HANDOVER"
-          }
-        };
-      }
-    };
-  }
-});
-
-// src/autonomous/stages/index.ts
-var init_stages = __esm({
-  "src/autonomous/stages/index.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_registry();
-    init_pick_ticket();
-    init_plan();
-    init_plan_review();
-    init_implement();
-    init_write_tests();
-    init_test();
-    init_code_review();
-    init_build();
-    init_verify();
-    init_finalize();
-    init_complete();
-    init_lesson_capture();
-    init_issue_fix();
-    init_issue_sweep();
-    init_handover2();
-    registerStage(new PickTicketStage());
-    registerStage(new PlanStage());
-    registerStage(new PlanReviewStage());
-    registerStage(new ImplementStage());
-    registerStage(new WriteTestsStage());
-    registerStage(new TestStage());
-    registerStage(new CodeReviewStage());
-    registerStage(new BuildStage());
-    registerStage(new VerifyStage());
-    registerStage(new FinalizeStage());
-    registerStage(new CompleteStage());
-    registerStage(new LessonCaptureStage());
-    registerStage(new IssueFixStage());
-    registerStage(new IssueSweepStage());
-    registerStage(new HandoverStage());
-  }
-});
-
-// src/autonomous/version-check.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join18, dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function checkVersionMismatch(runningVersion, installedVersion) {
-  if (!installedVersion) return null;
-  if (runningVersion === "0.0.0-dev") return null;
-  if (runningVersion === installedVersion) return null;
-  return `claudestory MCP server is running v${runningVersion} but v${installedVersion} is installed. Restart Claude Code to load the updated version.`;
+function sanitize(input, maxLen = 120) {
+  return input.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, maxLen);
 }
-function getInstalledVersion() {
+function writeResumeMarker(root, sessionId, state) {
   try {
-    const thisFile = fileURLToPath3(import.meta.url);
-    const candidates = [
-      join18(dirname4(thisFile), "..", "..", "package.json"),
-      join18(dirname4(thisFile), "..", "package.json")
+    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
     ];
-    for (const candidate of candidates) {
-      try {
-        const raw = readFileSync9(candidate, "utf-8");
-        const pkg = JSON.parse(raw);
-        if (pkg.version) return pkg.version;
-      } catch {
-      }
+    if (state.preCompactState) {
+      lines.push(`State before compaction: ${state.preCompactState}`);
     }
-    return null;
+    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 {
-    return null;
   }
 }
-function getRunningVersion() {
-  return "0.1.61";
+function removeResumeMarker(root) {
+  try {
+    const markerPath = join17(root, ".claude", "rules", MARKER_FILENAME);
+    if (existsSync11(markerPath)) unlinkSync3(markerPath);
+  } catch {
+  }
 }
-var init_version_check = __esm({
-  "src/autonomous/version-check.ts"() {
+var MARKER_FILENAME;
+var init_resume_marker = __esm({
+  "src/autonomous/resume-marker.ts"() {
     "use strict";
     init_esm_shims();
+    MARKER_FILENAME = "autonomous-resume.md";
   }
 });
 
-// src/autonomous/guide.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, readdirSync as readdirSync4 } from "fs";
-import { join as join19 } from "path";
-function buildGuideRecommendOptions(root) {
-  const opts = {};
-  try {
-    const handoversDir = join19(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");
-    }
-  } catch {
-  }
-  try {
-    const snapshotsDir = join19(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 snap = JSON.parse(raw);
-      if (snap.issues) {
-        opts.previousOpenIssueCount = snap.issues.filter((i) => i.status !== "resolved").length;
+// src/core/session-report-formatter.ts
+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)
       }
-    }
-  } catch {
+    }, null, 2);
   }
-  return opts;
-}
-async function buildTargetedResumeResult(root, state, dir) {
-  const remaining = getRemainingTargets(state);
+  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";
+  }
+}
+var init_session_report_formatter = __esm({
+  "src/core/session-report-formatter.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/autonomous/stages/handover.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join18 } from "path";
+var HandoverStage;
+var init_handover2 = __esm({
+  "src/autonomous/stages/handover.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_handover();
+    init_git_inspector();
+    init_resume_marker();
+    init_session_report_formatter();
+    init_project_loader();
+    init_queries();
+    HandoverStage = class {
+      id = "HANDOVER";
+      async enter(ctx) {
+        const ticketsDone = ctx.state.completedTickets.length;
+        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
+        return {
+          instruction: [
+            `# Session Complete \u2014 ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`,
+            "",
+            "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: [
+            "Before recording a new lesson, call claudestory_lesson_list to check existing lessons. Then choose: create (new insight), reinforce (existing lesson confirmed), update (refine wording), or skip."
+          ],
+          transitionedFrom: ctx.state.previousState ?? void 0
+        };
+      }
+      async report(ctx, report) {
+        const content = report.handoverContent;
+        if (!content) {
+          return { action: "retry", instruction: "Missing handoverContent. Write the handover and include it in the report." };
+        }
+        let handoverFailed = false;
+        try {
+          await handleHandoverCreate(content, "auto-session", "md", ctx.root);
+        } catch {
+          handoverFailed = true;
+          try {
+            const fallbackPath = join18(ctx.dir, "handover-fallback.md");
+            writeFileSync5(fallbackPath, content, "utf-8");
+          } catch {
+          }
+        }
+        let stashPopFailed = false;
+        const autoStash = ctx.state.git.autoStash;
+        if (autoStash) {
+          const popResult = await gitStashPop(ctx.root, autoStash.ref);
+          if (!popResult.ok) {
+            stashPopFailed = true;
+          }
+        }
+        await ctx.drainDeferrals();
+        const hasUnfiled = (ctx.state.pendingDeferrals ?? []).length > 0;
+        ctx.writeState({
+          state: "SESSION_END",
+          previousState: "HANDOVER",
+          status: "completed",
+          terminationReason: "normal",
+          deferralsUnfiled: hasUnfiled
+        });
+        ctx.appendEvent("session_end", {
+          ticketsCompleted: ctx.state.completedTickets.length,
+          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");
+        return {
+          action: "advance",
+          result: {
+            instruction: [
+              "# Session Complete",
+              "",
+              `${ticketsDone} ticket(s) and ${issuesDone} issue(s) completed.${handoverFailed ? " Handover creation failed \u2014 fallback saved to session directory." : " Handover written."}${stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : ""} Session ended.`,
+              "",
+              ctx.state.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n"),
+              ...resolvedList ? [resolvedList] : []
+            ].join("\n") + reportSection,
+            reminders: [],
+            transitionedFrom: "HANDOVER"
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/autonomous/stages/index.ts
+var init_stages = __esm({
+  "src/autonomous/stages/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_registry();
+    init_pick_ticket();
+    init_plan();
+    init_plan_review();
+    init_implement();
+    init_write_tests();
+    init_test();
+    init_code_review();
+    init_build();
+    init_verify();
+    init_finalize();
+    init_complete();
+    init_lesson_capture();
+    init_issue_fix();
+    init_issue_sweep();
+    init_handover2();
+    registerStage(new PickTicketStage());
+    registerStage(new PlanStage());
+    registerStage(new PlanReviewStage());
+    registerStage(new ImplementStage());
+    registerStage(new WriteTestsStage());
+    registerStage(new TestStage());
+    registerStage(new CodeReviewStage());
+    registerStage(new BuildStage());
+    registerStage(new VerifyStage());
+    registerStage(new FinalizeStage());
+    registerStage(new CompleteStage());
+    registerStage(new LessonCaptureStage());
+    registerStage(new IssueFixStage());
+    registerStage(new IssueSweepStage());
+    registerStage(new HandoverStage());
+  }
+});
+
+// src/autonomous/version-check.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join19, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function checkVersionMismatch(runningVersion, installedVersion) {
+  if (!installedVersion) return null;
+  if (runningVersion === "0.0.0-dev") return null;
+  if (runningVersion === installedVersion) return null;
+  return `claudestory MCP server is running v${runningVersion} but v${installedVersion} is installed. Restart Claude Code to load the updated version.`;
+}
+function getInstalledVersion() {
+  try {
+    const thisFile = fileURLToPath3(import.meta.url);
+    const candidates = [
+      join19(dirname4(thisFile), "..", "..", "package.json"),
+      join19(dirname4(thisFile), "..", "package.json")
+    ];
+    for (const candidate of candidates) {
+      try {
+        const raw = readFileSync9(candidate, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getRunningVersion() {
+  return "0.1.63";
+}
+var init_version_check = __esm({
+  "src/autonomous/version-check.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/autonomous/guide.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, readdirSync as readdirSync4 } from "fs";
+import { join as join20 } from "path";
+function buildGuideRecommendOptions(root) {
+  const opts = {};
+  try {
+    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(join20(handoversDir, files[files.length - 1]), "utf-8");
+    }
+  } catch {
+  }
+  try {
+    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(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;
+      }
+    }
+  } catch {
+  }
+  return opts;
+}
+async function buildTargetedResumeResult(root, state, dir) {
+  const remaining = getRemainingTargets(state);
   if (remaining.length === 0) {
     return { instruction: "", stuck: false, allDone: true, candidatesText: "" };
   }
@@ -11328,6 +11999,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;
@@ -11597,6 +12295,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 {
@@ -11719,7 +12418,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) {
@@ -11759,7 +12458,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 {
@@ -11770,13 +12469,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
@@ -11792,7 +12491,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) {
@@ -12189,8 +12888,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
@@ -12218,6 +12927,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.
 
 `;
@@ -12290,6 +13012,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
 
@@ -12311,8 +13056,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, [
@@ -12426,6 +13186,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", {
@@ -12531,9 +13297,22 @@ async function handleCancel(root, args) {
       stashPopFailed
     }
   });
+  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 {
+  }
   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}` }]
+    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) and ${(written.resolvedIssues ?? []).length} issue(s) were completed.${stashNote}${reportSection}` }]
   };
 }
 function guideResult(state, currentState, opts) {
@@ -12580,268 +13359,74 @@ ${output.reminders.map((r) => `- ${r}`).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 "";
-  }
-}
-var RECOVERY_MAPPING, SEVERITY_MAP, workspaceLocks, MAX_AUTO_ADVANCE_DEPTH;
-var init_guide = __esm({
-  "src/autonomous/guide.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_session_types();
-    init_session();
-    init_state_machine();
-    init_context_pressure();
-    init_review_depth();
-    init_git_inspector();
-    init_loader();
-    init_registry();
-    init_types3();
-    init_stages();
-    init_project_loader();
-    init_lessons();
-    init_snapshot();
-    init_snapshot();
-    init_queries();
-    init_recommend();
-    init_version_check();
-    init_target_work();
-    init_handover();
-    RECOVERY_MAPPING = {
-      PICK_TICKET: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
-      COMPLETE: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
-      HANDOVER: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
-      PLAN: { state: "PLAN", resetPlan: true, resetCode: false },
-      IMPLEMENT: { state: "PLAN", resetPlan: true, resetCode: false },
-      WRITE_TESTS: { state: "PLAN", resetPlan: true, resetCode: false },
-      BUILD: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
-      VERIFY: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
-      PLAN_REVIEW: { state: "PLAN", resetPlan: true, resetCode: true },
-      TEST: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
-      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_SWEEP: { state: "PICK_TICKET", resetPlan: false, resetCode: false }
-    };
-    SEVERITY_MAP = {
-      critical: "critical",
-      major: "high",
-      minor: "medium"
-    };
-    workspaceLocks = /* @__PURE__ */ new Map();
-    MAX_AUTO_ADVANCE_DEPTH = 10;
-  }
-});
-
-// src/core/session-report-formatter.ts
-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}`);
-    }
-  } 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");
+    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 "";
   }
 }
-var init_session_report_formatter = __esm({
-  "src/core/session-report-formatter.ts"() {
+var RECOVERY_MAPPING, SEVERITY_MAP, workspaceLocks, MAX_AUTO_ADVANCE_DEPTH;
+var init_guide = __esm({
+  "src/autonomous/guide.ts"() {
     "use strict";
     init_esm_shims();
+    init_session_types();
+    init_session();
+    init_state_machine();
+    init_context_pressure();
+    init_review_depth();
+    init_git_inspector();
+    init_loader();
+    init_registry();
+    init_types3();
+    init_stages();
+    init_project_loader();
+    init_lessons();
+    init_snapshot();
+    init_snapshot();
+    init_queries();
+    init_recommend();
+    init_version_check();
+    init_resume_marker();
+    init_session_report_formatter();
+    init_target_work();
+    init_handover();
+    RECOVERY_MAPPING = {
+      PICK_TICKET: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
+      COMPLETE: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
+      HANDOVER: { state: "PICK_TICKET", resetPlan: false, resetCode: false },
+      PLAN: { state: "PLAN", resetPlan: true, resetCode: false },
+      IMPLEMENT: { state: "PLAN", resetPlan: true, resetCode: false },
+      WRITE_TESTS: { state: "PLAN", resetPlan: true, resetCode: false },
+      BUILD: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
+      VERIFY: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
+      PLAN_REVIEW: { state: "PLAN", resetPlan: true, resetCode: true },
+      TEST: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
+      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: "ISSUE_FIX", resetPlan: false, resetCode: false },
+      // T-208: self-recover to avoid dangling currentIssue
+      ISSUE_SWEEP: { state: "PICK_TICKET", resetPlan: false, resetCode: false }
+    };
+    SEVERITY_MAP = {
+      critical: "critical",
+      major: "high",
+      minor: "medium"
+    };
+    workspaceLocks = /* @__PURE__ */ new Map();
+    MAX_AUTO_ADVANCE_DEPTH = 10;
   }
 });
 
 // src/cli/commands/session-report.ts
-import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import { join as join21 } from "path";
 async function handleSessionReport(sessionId, root, format = "md") {
   if (!UUID_REGEX.test(sessionId)) {
     return {
@@ -12852,7 +13437,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,
@@ -12860,8 +13445,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,
@@ -12899,7 +13484,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;
@@ -12928,7 +13513,7 @@ var init_session_report = __esm({
 });
 
 // src/cli/commands/phase.ts
-import { join as join21, resolve as resolve7 } from "path";
+import { join as join22, resolve as resolve7 } from "path";
 function validatePhaseId(id) {
   if (id.length > PHASE_ID_MAX_LENGTH) {
     throw new CliValidationError("invalid_input", `Phase ID "${id}" exceeds ${PHASE_ID_MAX_LENGTH} characters`);
@@ -13117,21 +13702,21 @@ async function handlePhaseDelete(id, reassign, format, root) {
         const updated = { ...ticket, phase: reassign, order: maxOrder };
         const parsed = TicketSchema.parse(updated);
         const content = serializeJSON(parsed);
-        const target = join21(wrapDir, "tickets", `${parsed.id}.json`);
+        const target = join22(wrapDir, "tickets", `${parsed.id}.json`);
         operations.push({ op: "write", target, content });
       }
       for (const issue of affectedIssues) {
         const updated = { ...issue, phase: reassign };
         const parsed = IssueSchema.parse(updated);
         const content = serializeJSON(parsed);
-        const target = join21(wrapDir, "issues", `${parsed.id}.json`);
+        const target = join22(wrapDir, "issues", `${parsed.id}.json`);
         operations.push({ op: "write", target, content });
       }
       const newPhases = state.roadmap.phases.filter((p) => p.id !== id);
       const newRoadmap = { ...state.roadmap, phases: newPhases };
       const parsedRoadmap = RoadmapSchema.parse(newRoadmap);
       const roadmapContent = serializeJSON(parsedRoadmap);
-      const roadmapTarget = join21(wrapDir, "roadmap.json");
+      const roadmapTarget = join22(wrapDir, "roadmap.json");
       operations.push({ op: "write", target: roadmapTarget, content: roadmapContent });
       await runTransactionUnlocked(root, operations);
     } else {
@@ -13164,14 +13749,15 @@ var init_phase = __esm({
 
 // src/mcp/tools.ts
 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";
 function formatMcpError(code, message) {
   return `[${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)) {
@@ -13719,6 +14305,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)")
     }
@@ -13743,7 +14330,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({
@@ -13754,9 +14341,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,
@@ -13767,9 +14358,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 };
@@ -13810,7 +14447,23 @@ function registerAllTools(server, pinnedRoot) {
     }
   });
 }
-var INFRASTRUCTURE_ERROR_CODES;
+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 {
+  }
+}
+var INFRASTRUCTURE_ERROR_CODES, FILED_PREEXISTING_FILE;
 var init_tools = __esm({
   "src/mcp/tools.ts"() {
     "use strict";
@@ -13843,15 +14496,16 @@ var init_tools = __esm({
       "project_corrupt",
       "version_mismatch"
     ];
+    FILED_PREEXISTING_FILE = "filed-preexisting.json";
   }
 });
 
 // src/core/init.ts
 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);
@@ -13871,11 +14525,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",
@@ -13915,7 +14569,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) {
@@ -13960,11 +14614,405 @@ var init_init = __esm({
   }
 });
 
+// src/channel/events.ts
+import { z as z11 } from "zod";
+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;
+}
+var TicketRequestedPayload, PauseSessionPayload, ResumeSessionPayload, CancelSessionPayload, PriorityChangedPayload, PermissionResponsePayload, ChannelEventSchema, VALID_FILENAME;
+var init_events = __esm({
+  "src/channel/events.ts"() {
+    "use strict";
+    init_esm_shims();
+    TicketRequestedPayload = z11.object({
+      ticketId: z11.string().regex(/^T-\d+[a-z]?$/)
+    });
+    PauseSessionPayload = z11.object({});
+    ResumeSessionPayload = z11.object({});
+    CancelSessionPayload = z11.object({
+      reason: z11.string().max(1e3).optional()
+    });
+    PriorityChangedPayload = z11.object({
+      ticketId: z11.string().regex(/^T-\d+[a-z]?$/),
+      newOrder: z11.number().int()
+    });
+    PermissionResponsePayload = z11.object({
+      requestId: z11.string().regex(/^[a-zA-Z0-9]{5}$/),
+      behavior: z11.enum(["approve", "deny"])
+    });
+    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
+      })
+    ]);
+    VALID_FILENAME = /^[\d]{4}-[\d]{2}-[\d]{2}T[\w.:-]+-[\w]+\.json$/;
+  }
+});
+
+// src/channel/inbox-watcher.ts
+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";
+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);
+}
+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 {
+    }
+  }
+}
+var INBOX_DIR, FAILED_DIR, MAX_INBOX_DEPTH, MAX_FAILED_FILES, DEBOUNCE_MS, MAX_PERMISSION_RETRIES, MAX_EVENT_RETRIES, EVENT_EXPIRY_MS, watcher, permissionRetryCount, eventRetryCount, debounceTimer, pollInterval;
+var init_inbox_watcher = __esm({
+  "src/channel/inbox-watcher.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_events();
+    INBOX_DIR = "channel-inbox";
+    FAILED_DIR = ".failed";
+    MAX_INBOX_DEPTH = 50;
+    MAX_FAILED_FILES = 20;
+    DEBOUNCE_MS = 100;
+    MAX_PERMISSION_RETRIES = 15;
+    MAX_EVENT_RETRIES = 30;
+    EVENT_EXPIRY_MS = 6e4;
+    watcher = null;
+    permissionRetryCount = /* @__PURE__ */ new Map();
+    eventRetryCount = /* @__PURE__ */ new Map();
+    debounceTimer = null;
+    pollInterval = null;
+  }
+});
+
 // src/mcp/index.ts
 var mcp_exports = {};
-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";
 function tryDiscoverRoot() {
@@ -13978,7 +15026,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}
@@ -14006,9 +15054,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;
@@ -14038,6 +15086,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}
 `);
@@ -14057,17 +15111,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);
 }
@@ -14079,9 +15148,10 @@ var init_mcp = __esm({
     init_project_root_discovery();
     init_tools();
     init_init();
+    init_inbox_watcher();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.61";
+    version = "0.1.63";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -14117,7 +15187,7 @@ __export(run_exports, {
   runReadCommand: () => runReadCommand,
   writeOutput: () => writeOutput
 });
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 function writeOutput(text) {
   try {
     process.stdout.write(text + "\n");
@@ -14145,7 +15215,7 @@ async function runReadCommand(format, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join25(root, ".story", "handovers");
+    const handoversDir = join27(root, ".story", "handovers");
     const result = await handler({ state, warnings, root, handoversDir, format });
     writeOutput(result.output);
     let exitCode = result.exitCode ?? ExitCode.OK;
@@ -14180,7 +15250,7 @@ async function runDeleteCommand(format, force, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join25(root, ".story", "handovers");
+    const handoversDir = join27(root, ".story", "handovers");
     if (!force && hasIntegrityWarnings(warnings)) {
       writeOutput(
         formatError(
@@ -14696,9 +15766,9 @@ __export(setup_skill_exports, {
   removeHook: () => removeHook,
   resolveSkillSourceDir: () => resolveSkillSourceDir
 });
-import { mkdir as mkdir5, writeFile as writeFile3, readFile as readFile5, readdir as readdir4, copyFile, rm, rename as rename2, unlink as unlink3 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import { join as join26, dirname as dirname5 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile3, readFile as readFile6, readdir as readdir5, copyFile, rm, rename as rename3, unlink as unlink4 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { join as join28, dirname as dirname5 } from "path";
 import { homedir } from "os";
 import { execFileSync as execFileSync2 } from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -14707,10 +15777,10 @@ function log(msg) {
 }
 function resolveSkillSourceDir() {
   const thisDir = dirname5(fileURLToPath4(import.meta.url));
-  const bundledPath = join26(thisDir, "..", "src", "skill");
-  if (existsSync14(join26(bundledPath, "SKILL.md"))) return bundledPath;
-  const sourcePath = join26(thisDir, "..", "..", "skill");
-  if (existsSync14(join26(sourcePath, "SKILL.md"))) return sourcePath;
+  const bundledPath = join28(thisDir, "..", "src", "skill");
+  if (existsSync15(join28(bundledPath, "SKILL.md"))) return bundledPath;
+  const sourcePath = join28(thisDir, "..", "..", "skill");
+  if (existsSync15(join28(sourcePath, "SKILL.md"))) return sourcePath;
   throw new Error(
     `Cannot find bundled skill files. Checked:
   ${bundledPath}
@@ -14720,31 +15790,31 @@ function resolveSkillSourceDir() {
 async function copyDirRecursive(srcDir, destDir) {
   const tmpDir = destDir + ".tmp";
   const bakDir = destDir + ".bak";
-  if (!existsSync14(destDir) && existsSync14(bakDir)) {
-    await rename2(bakDir, destDir);
+  if (!existsSync15(destDir) && existsSync15(bakDir)) {
+    await rename3(bakDir, destDir);
   }
-  if (existsSync14(tmpDir)) await rm(tmpDir, { recursive: true, force: true });
-  if (existsSync14(bakDir)) await rm(bakDir, { recursive: true, force: true });
-  await mkdir5(tmpDir, { recursive: true });
-  const entries = await readdir4(srcDir, { withFileTypes: true, recursive: true });
+  if (existsSync15(tmpDir)) await rm(tmpDir, { recursive: true, force: true });
+  if (existsSync15(bakDir)) await rm(bakDir, { recursive: true, force: true });
+  await mkdir6(tmpDir, { recursive: true });
+  const entries = await readdir5(srcDir, { withFileTypes: true, recursive: true });
   const written = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const parent = entry.parentPath ?? entry.path ?? srcDir;
-    const relativePath = join26(parent, entry.name).slice(srcDir.length + 1);
-    const srcPath = join26(srcDir, relativePath);
-    const destPath = join26(tmpDir, relativePath);
-    await mkdir5(dirname5(destPath), { recursive: true });
+    const relativePath = join28(parent, entry.name).slice(srcDir.length + 1);
+    const srcPath = join28(srcDir, relativePath);
+    const destPath = join28(tmpDir, relativePath);
+    await mkdir6(dirname5(destPath), { recursive: true });
     await copyFile(srcPath, destPath);
     written.push(relativePath);
   }
-  if (existsSync14(destDir)) {
-    await rename2(destDir, bakDir);
+  if (existsSync15(destDir)) {
+    await rename3(destDir, bakDir);
   }
   try {
-    await rename2(tmpDir, destDir);
+    await rename3(tmpDir, destDir);
   } catch (err) {
-    if (existsSync14(bakDir)) await rename2(bakDir, destDir).catch(() => {
+    if (existsSync15(bakDir)) await rename3(bakDir, destDir).catch(() => {
     });
     await rm(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -14760,11 +15830,11 @@ function isHookWithCommand(entry, command) {
   return e.type === "command" && typeof e.command === "string" && e.command.trim() === command;
 }
 async function registerHook(hookType, hookEntry, settingsPath, matcher) {
-  const path2 = settingsPath ?? join26(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join28(homedir(), ".claude", "settings.json");
   let raw = "{}";
-  if (existsSync14(path2)) {
+  if (existsSync15(path2)) {
     try {
-      raw = await readFile5(path2, "utf-8");
+      raw = await readFile6(path2, "utf-8");
     } catch {
       process.stderr.write(`Could not read ${path2} \u2014 skipping hook registration.
 `);
@@ -14833,12 +15903,12 @@ async function registerHook(hookType, hookEntry, settingsPath, matcher) {
   const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
     const dir = dirname5(path2);
-    await mkdir5(dir, { recursive: true });
+    await mkdir6(dir, { recursive: true });
     await writeFile3(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename2(tmpPath, path2);
+    await rename3(tmpPath, path2);
   } catch (err) {
     try {
-      await unlink3(tmpPath);
+      await unlink4(tmpPath);
     } catch {
     }
     const message = err instanceof Error ? err.message : String(err);
@@ -14858,11 +15928,11 @@ async function registerStopHook(settingsPath) {
   return registerHook("Stop", { type: "command", command: STOP_HOOK_COMMAND, async: true }, settingsPath);
 }
 async function removeHook(hookType, command, settingsPath) {
-  const path2 = settingsPath ?? join26(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join28(homedir(), ".claude", "settings.json");
   let raw = "{}";
-  if (existsSync14(path2)) {
+  if (existsSync15(path2)) {
     try {
-      raw = await readFile5(path2, "utf-8");
+      raw = await readFile6(path2, "utf-8");
     } catch {
       return "skipped";
     }
@@ -14891,12 +15961,12 @@ async function removeHook(hookType, command, settingsPath) {
   const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
     const dir = dirname5(path2);
-    await mkdir5(dir, { recursive: true });
+    await mkdir6(dir, { recursive: true });
     await writeFile3(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename2(tmpPath, path2);
+    await rename3(tmpPath, path2);
   } catch {
     try {
-      await unlink3(tmpPath);
+      await unlink4(tmpPath);
     } catch {
     }
     return "skipped";
@@ -14905,8 +15975,8 @@ async function removeHook(hookType, command, settingsPath) {
 }
 async function handleSetupSkill(options = {}) {
   const { skipHooks = false } = options;
-  const skillDir = join26(homedir(), ".claude", "skills", "story");
-  await mkdir5(skillDir, { recursive: true });
+  const skillDir = join28(homedir(), ".claude", "skills", "story");
+  await mkdir6(skillDir, { recursive: true });
   let srcSkillDir;
   try {
     srcSkillDir = resolveSkillSourceDir();
@@ -14918,31 +15988,31 @@ async function handleSetupSkill(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const oldPrimeDir = join26(homedir(), ".claude", "skills", "prime");
-  if (existsSync14(oldPrimeDir)) {
+  const oldPrimeDir = join28(homedir(), ".claude", "skills", "prime");
+  if (existsSync15(oldPrimeDir)) {
     await rm(oldPrimeDir, { recursive: true, force: true });
     log("Removed old /prime skill (migrated to /story)");
   }
-  const existed = existsSync14(join26(skillDir, "SKILL.md"));
-  const skillContent = await readFile5(join26(srcSkillDir, "SKILL.md"), "utf-8");
-  await writeFile3(join26(skillDir, "SKILL.md"), skillContent, "utf-8");
+  const existed = existsSync15(join28(skillDir, "SKILL.md"));
+  const skillContent = await readFile6(join28(srcSkillDir, "SKILL.md"), "utf-8");
+  await writeFile3(join28(skillDir, "SKILL.md"), skillContent, "utf-8");
   const supportFiles = ["setup-flow.md", "autonomous-mode.md", "reference.md"];
   const writtenFiles = ["SKILL.md"];
   const missingFiles = [];
   for (const filename of supportFiles) {
-    const srcPath = join26(srcSkillDir, filename);
-    if (existsSync14(srcPath)) {
-      const content = await readFile5(srcPath, "utf-8");
-      await writeFile3(join26(skillDir, filename), content, "utf-8");
+    const srcPath = join28(srcSkillDir, filename);
+    if (existsSync15(srcPath)) {
+      const content = await readFile6(srcPath, "utf-8");
+      await writeFile3(join28(skillDir, filename), content, "utf-8");
       writtenFiles.push(filename);
     } else {
       missingFiles.push(filename);
     }
   }
   for (const subdir of ["design", "review-lenses"]) {
-    const srcDir = join26(srcSkillDir, subdir);
-    if (existsSync14(srcDir)) {
-      const destDir = join26(skillDir, subdir);
+    const srcDir = join28(srcSkillDir, subdir);
+    if (existsSync15(srcDir)) {
+      const destDir = join28(skillDir, subdir);
       try {
         const files = await copyDirRecursive(srcDir, destDir);
         for (const f of files) writtenFiles.push(`${subdir}/${f}`);
@@ -15066,8 +16136,8 @@ var hook_status_exports = {};
 __export(hook_status_exports, {
   handleHookStatus: () => handleHookStatus
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, renameSync as renameSync3, unlinkSync as unlinkSync4 } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync8, renameSync as renameSync3, unlinkSync as unlinkSync5 } from "fs";
+import { join as join29 } from "path";
 async function readStdinSilent() {
   try {
     const chunks = [];
@@ -15084,12 +16154,12 @@ async function readStdinSilent() {
 function atomicWriteSync(targetPath, content) {
   const tmp = `${targetPath}.${process.pid}.tmp`;
   try {
-    writeFileSync6(tmp, content, "utf-8");
+    writeFileSync8(tmp, content, "utf-8");
     renameSync3(tmp, targetPath);
     return true;
   } catch {
     try {
-      unlinkSync4(tmp);
+      unlinkSync5(tmp);
     } catch {
     }
     return false;
@@ -15117,10 +16187,10 @@ function activePayload(session) {
   };
 }
 function ensureGitignore(root) {
-  const gitignorePath = join27(root, ".story", ".gitignore");
+  const gitignorePath = join29(root, ".story", ".gitignore");
   let existing = "";
   try {
-    existing = readFileSync12(gitignorePath, "utf-8");
+    existing = readFileSync13(gitignorePath, "utf-8");
   } catch {
   }
   const lines = existing.split("\n").map((l) => l.trim());
@@ -15130,13 +16200,13 @@ function ensureGitignore(root) {
   if (content.length > 0 && !content.endsWith("\n")) content += "\n";
   content += missing.join("\n") + "\n";
   try {
-    writeFileSync6(gitignorePath, content, "utf-8");
+    writeFileSync8(gitignorePath, content, "utf-8");
   } catch {
   }
 }
 function writeStatus(root, payload) {
   ensureGitignore(root);
-  const statusPath = join27(root, ".story", "status.json");
+  const statusPath = join29(root, ".story", "status.json");
   const content = JSON.stringify(payload, null, 2) + "\n";
   atomicWriteSync(statusPath, content);
 }
@@ -15195,8 +16265,8 @@ var config_update_exports = {};
 __export(config_update_exports, {
   handleConfigSetOverrides: () => handleConfigSetOverrides
 });
-import { readFileSync as readFileSync13 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { join as join30 } from "path";
 async function handleConfigSetOverrides(root, format, options) {
   const { json: jsonArg, clear } = options;
   if (!clear && !jsonArg) {
@@ -15224,8 +16294,8 @@ async function handleConfigSetOverrides(root, format, options) {
   }
   let resultOverrides = null;
   await withProjectLock(root, { strict: false }, async () => {
-    const configPath = join28(root, ".story", "config.json");
-    const rawContent = readFileSync13(configPath, "utf-8");
+    const configPath = join30(root, ".story", "config.json");
+    const rawContent = readFileSync14(configPath, "utf-8");
     const raw = JSON.parse(rawContent);
     if (clear) {
       delete raw.recipeOverrides;
@@ -15296,6 +16366,12 @@ async function handleSessionCompactPrepare() {
 `);
         return;
       }
+      writeResumeMarker(root, active.state.sessionId, {
+        ticket: active.state.ticket,
+        completedTickets: active.state.completedTickets,
+        resolvedIssues: active.state.resolvedIssues,
+        preCompactState: active.state.preCompactState ?? active.state.state
+      });
       try {
         const loadResult = await loadProject(root);
         const { saveSnapshot: saveSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
@@ -15312,7 +16388,10 @@ async function handleSessionResumePrompt() {
   const root = discoverProjectRoot();
   if (!root) return;
   const match = findResumableSession(root);
-  if (!match) return;
+  if (!match) {
+    removeResumeMarker(root);
+    return;
+  }
   const { info, stale } = match;
   const sessionId = info.state.sessionId;
   if (stale) {
@@ -15387,6 +16466,7 @@ claudestory_autonomous_guide {"sessionId": "${info.state.sessionId}", "action":
         ticketId: info.state.ticket?.id ?? null
       }
     });
+    removeResumeMarker(root);
     return `Session ${info.state.sessionId} ended (unrecoverable \u2014 invalid preCompactState: ${preCompactState ?? "null"}). Run "start" for a new session.`;
   });
 }
@@ -15442,6 +16522,7 @@ async function handleSessionStop(root, sessionId) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       data: { previousState: info.state.state, ticketId: ticketId ?? null, ticketReleased }
     });
+    removeResumeMarker(root);
     return `Session ${info.state.sessionId} stopped.${ticketReleased ? ` Ticket ${ticketId} released to open.` : ticketId ? ` Ticket ${ticketId} may need manual cleanup.` : ""}`;
   });
 }
@@ -15453,6 +16534,7 @@ var init_session_compact = __esm({
     init_session();
     init_session_types();
     init_project_loader();
+    init_resume_marker();
   }
 });
 
@@ -17568,7 +18650,7 @@ async function runCli() {
     registerSessionCommand: registerSessionCommand2,
     registerRepairCommand: registerRepairCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.61";
+  const version2 = "0.1.63";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");