@anthropologies/claudestory 0.1.35 → 0.1.37

package/dist/cli.js

@@ -1761,7 +1761,7 @@ function fencedBlock(content, lang) {
 ${content}
 ${fence}`;
 }
-function formatStatus(state, format) {
+function formatStatus(state, format, activeSessions = []) {
   const phases = phasesWithStatus(state);
   const data = {
     project: state.config.project,
@@ -1781,7 +1781,8 @@ function formatStatus(state, format) {
       name: p.phase.name,
       status: p.status,
       leafCount: p.leafCount
-    }))
+    })),
+    ...activeSessions.length > 0 ? { activeSessions } : {}
   };
   if (format === "json") {
     return JSON.stringify(successEnvelope(data), null, 2);
@@ -1803,6 +1804,15 @@ function formatStatus(state, format) {
     const summary = p.phase.summary ?? truncate(p.phase.description, 80);
     lines.push(`${indicator} **${escapeMarkdownInline(p.phase.name)}** (${p.leafCount} tickets) \u2014 ${escapeMarkdownInline(summary)}`);
   }
+  if (activeSessions.length > 0) {
+    lines.push("");
+    lines.push("## Active Sessions");
+    lines.push("");
+    for (const s of activeSessions) {
+      const ticket = s.ticketId ? `${s.ticketId}: ${escapeMarkdownInline(s.ticketTitle ?? "")}` : "no ticket";
+      lines.push(`- ${s.sessionId.slice(0, 8)}: ${s.state} -- ${ticket} (${s.mode} mode)`);
+    }
+  }
   if (state.isEmptyScaffold) {
     lines.push("");
     lines.push(EMPTY_SCAFFOLD_HEADING);
@@ -2691,15 +2701,71 @@ var init_output_formatter = __esm({
   }
 });
 
+// src/core/session-scan.ts
+import { readdirSync, readFileSync } from "fs";
+import { join as join4 } from "path";
+function scanActiveSessions(root) {
+  const sessDir = join4(root, ".story", "sessions");
+  let entries;
+  try {
+    entries = readdirSync(sessDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const statePath2 = join4(sessDir, entry.name, "state.json");
+    let raw;
+    try {
+      raw = readFileSync(statePath2, "utf-8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (parsed.status !== "active") continue;
+    if (parsed.state === "SESSION_END") continue;
+    const lease = parsed.lease;
+    if (lease?.expiresAt) {
+      const expires = new Date(lease.expiresAt).getTime();
+      if (!Number.isNaN(expires) && expires <= Date.now()) continue;
+    } else {
+      continue;
+    }
+    const ticket = parsed.ticket;
+    results.push({
+      sessionId: parsed.sessionId ?? entry.name,
+      state: parsed.state ?? "unknown",
+      mode: parsed.mode ?? "auto",
+      ticketId: ticket?.id ?? null,
+      ticketTitle: ticket?.title ?? null
+    });
+  }
+  return results;
+}
+var init_session_scan = __esm({
+  "src/core/session-scan.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/cli/commands/status.ts
 function handleStatus(ctx) {
-  return { output: formatStatus(ctx.state, ctx.format) };
+  const sessions = scanActiveSessions(ctx.root);
+  return { output: formatStatus(ctx.state, ctx.format, sessions) };
 }
 var init_status = __esm({
   "src/cli/commands/status.ts"() {
     "use strict";
     init_esm_shims();
     init_output_formatter();
+    init_session_scan();
   }
 });
 
@@ -2787,6 +2853,7 @@ function validateProject(state) {
       }
     }
   }
+  detectSupersedesCycles(state, findings);
   const phaseIDCounts = /* @__PURE__ */ new Map();
   for (const p of state.roadmap.phases) {
     phaseIDCounts.set(p.id, (phaseIDCounts.get(p.id) ?? 0) + 1);
@@ -2991,6 +3058,33 @@ function dfsBlocked(id, state, visited, inStack, findings) {
   inStack.delete(id);
   visited.add(id);
 }
+function detectSupersedesCycles(state, findings) {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  for (const l of state.lessons) {
+    if (l.supersedes == null || visited.has(l.id)) continue;
+    dfsSupersedesChain(l.id, state, visited, inStack, findings);
+  }
+}
+function dfsSupersedesChain(id, state, visited, inStack, findings) {
+  if (inStack.has(id)) {
+    findings.push({
+      level: "error",
+      code: "supersedes_cycle",
+      message: `Cycle detected in supersedes chain involving ${id}.`,
+      entity: id
+    });
+    return;
+  }
+  if (visited.has(id)) return;
+  inStack.add(id);
+  const lesson = state.lessonByID(id);
+  if (lesson?.supersedes && lesson.supersedes !== id) {
+    dfsSupersedesChain(lesson.supersedes, state, visited, inStack, findings);
+  }
+  inStack.delete(id);
+  visited.add(id);
+}
 var init_validation = __esm({
   "src/core/validation.ts"() {
     "use strict";
@@ -3027,7 +3121,7 @@ __export(handover_exports, {
 });
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { join as join4, resolve as resolve4 } from "path";
+import { join as join5, resolve as resolve4 } from "path";
 function handleHandoverList(ctx) {
   return { output: formatHandoverList(ctx.state.handoverFilenames, ctx.format) };
 }
@@ -3112,15 +3206,15 @@ async function handleHandoverCreate(content, slugRaw, format, root) {
   let filename;
   await withProjectLock(root, { strict: false }, async () => {
     const absRoot = resolve4(root);
-    const handoversDir = join4(absRoot, ".story", "handovers");
+    const handoversDir = join5(absRoot, ".story", "handovers");
     await mkdir2(handoversDir, { recursive: true });
-    const wrapDir = join4(absRoot, ".story");
+    const wrapDir = join5(absRoot, ".story");
     const datePrefix = `${date}-`;
     const seqRegex = new RegExp(`^${date}-(\\d{2})-`);
     let maxSeq = 0;
-    const { readdirSync: readdirSync2 } = await import("fs");
+    const { readdirSync: readdirSync5 } = await import("fs");
     try {
-      for (const f of readdirSync2(handoversDir)) {
+      for (const f of readdirSync5(handoversDir)) {
         const m = f.match(seqRegex);
         if (m) {
           const n = parseInt(m[1], 10);
@@ -3137,7 +3231,7 @@ async function handleHandoverCreate(content, slugRaw, format, root) {
       );
     }
     let candidate = `${date}-${String(nextSeq).padStart(2, "0")}-${slug}.md`;
-    let candidatePath = join4(handoversDir, candidate);
+    let candidatePath = join5(handoversDir, candidate);
     while (existsSync4(candidatePath)) {
       nextSeq++;
       if (nextSeq > 99) {
@@ -3147,7 +3241,7 @@ async function handleHandoverCreate(content, slugRaw, format, root) {
         );
       }
       candidate = `${date}-${String(nextSeq).padStart(2, "0")}-${slug}.md`;
-      candidatePath = join4(handoversDir, candidate);
+      candidatePath = join5(handoversDir, candidate);
     }
     await parseHandoverFilename(candidate, handoversDir);
     await guardPath(candidatePath, wrapDir);
@@ -3780,11 +3874,11 @@ __export(snapshot_exports, {
 });
 import { readdir as readdir3, readFile as readFile3, mkdir as mkdir3, unlink as unlink2 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5, resolve as resolve5 } from "path";
+import { join as join6, resolve as resolve5 } from "path";
 import { z as z8 } from "zod";
 async function saveSnapshot(root, loadResult) {
   const absRoot = resolve5(root);
-  const snapshotsDir = join5(absRoot, ".story", "snapshots");
+  const snapshotsDir = join6(absRoot, ".story", "snapshots");
   await mkdir3(snapshotsDir, { recursive: true });
   const { state, warnings } = loadResult;
   const now = /* @__PURE__ */ new Date();
@@ -3809,8 +3903,8 @@ async function saveSnapshot(root, loadResult) {
     } : {}
   };
   const json = JSON.stringify(snapshot, null, 2) + "\n";
-  const targetPath = join5(snapshotsDir, filename);
-  const wrapDir = join5(absRoot, ".story");
+  const targetPath = join6(snapshotsDir, filename);
+  const wrapDir = join6(absRoot, ".story");
   await guardPath(targetPath, wrapDir);
   await atomicWrite(targetPath, json);
   const pruned = await pruneSnapshots(snapshotsDir);
@@ -3818,13 +3912,13 @@ async function saveSnapshot(root, loadResult) {
   return { filename, retained: entries.length, pruned };
 }
 async function loadLatestSnapshot(root) {
-  const snapshotsDir = join5(resolve5(root), ".story", "snapshots");
+  const snapshotsDir = join6(resolve5(root), ".story", "snapshots");
   if (!existsSync5(snapshotsDir)) return null;
   const files = await listSnapshotFiles(snapshotsDir);
   if (files.length === 0) return null;
   for (const filename of files) {
     try {
-      const content = await readFile3(join5(snapshotsDir, filename), "utf-8");
+      const content = await readFile3(join6(snapshotsDir, filename), "utf-8");
       const parsed = JSON.parse(content);
       const snapshot = SnapshotV1Schema.parse(parsed);
       return { snapshot, filename };
@@ -4068,7 +4162,7 @@ async function pruneSnapshots(dir) {
   const toRemove = files.slice(MAX_SNAPSHOTS);
   for (const f of toRemove) {
     try {
-      await unlink2(join5(dir, f));
+      await unlink2(join6(dir, f));
     } catch {
     }
   }
@@ -4487,7 +4581,7 @@ var init_lesson2 = __esm({
 });
 
 // src/core/recommend.ts
-function recommend(state, count) {
+function recommend(state, count, options) {
   const effectiveCount = Math.max(1, Math.min(10, count));
   const dedup = /* @__PURE__ */ new Map();
   const phaseIndex = buildPhaseIndex(state);
@@ -4499,7 +4593,8 @@ function recommend(state, count) {
     () => generateNearCompleteUmbrellas(state, phaseIndex),
     () => generatePhaseMomentum(state),
     () => generateQuickWins(state, phaseIndex),
-    () => generateOpenIssues(state)
+    () => generateOpenIssues(state),
+    () => generateDebtTrend(state, options)
   ];
   for (const gen of generators) {
     for (const rec of gen()) {
@@ -4509,6 +4604,7 @@ function recommend(state, count) {
       }
     }
   }
+  applyHandoverBoost(state, dedup, options);
   const curPhase = currentPhase(state);
   const curPhaseIdx = curPhase ? phaseIndex.get(curPhase.id) ?? 0 : 0;
   for (const [id, rec] of dedup) {
@@ -4698,7 +4794,76 @@ function sortByPhaseAndOrder(tickets, phaseIndex) {
     return a.order - b.order;
   });
 }
-var SEVERITY_RANK, PHASE_DISTANCE_PENALTY, MAX_PHASE_PENALTY, CATEGORY_PRIORITY;
+function applyHandoverBoost(state, dedup, options) {
+  if (!options?.latestHandoverContent) return;
+  const content = options.latestHandoverContent;
+  let actionableIds = extractTicketIdsFromActionableSections(content);
+  if (actionableIds.size === 0) {
+    const allIds = new Set(content.match(TICKET_ID_RE) ?? []);
+    for (const id of allIds) {
+      const ticket = state.ticketByID(id);
+      if (ticket && ticket.status !== "complete" && ticket.status !== "inprogress") {
+        actionableIds.add(id);
+      }
+    }
+  }
+  for (const id of actionableIds) {
+    const ticket = state.ticketByID(id);
+    if (!ticket || ticket.status === "complete") continue;
+    const existing = dedup.get(id);
+    if (existing) {
+      dedup.set(id, {
+        ...existing,
+        score: existing.score + HANDOVER_BOOST,
+        reason: existing.reason + " (handover context)"
+      });
+    } else {
+      dedup.set(id, {
+        id,
+        kind: "ticket",
+        title: ticket.title,
+        category: "handover_context",
+        reason: "Referenced in latest handover",
+        score: HANDOVER_BASE_SCORE
+      });
+    }
+  }
+}
+function extractTicketIdsFromActionableSections(content) {
+  const ids = /* @__PURE__ */ new Set();
+  const lines = content.split("\n");
+  let inActionable = false;
+  for (const line of lines) {
+    if (/^#+\s/.test(line)) {
+      inActionable = ACTIONABLE_HEADING_RE.test(line);
+    }
+    if (inActionable) {
+      const matches = line.match(TICKET_ID_RE);
+      if (matches) for (const m of matches) ids.add(m);
+    }
+  }
+  return ids;
+}
+function generateDebtTrend(state, options) {
+  if (options?.previousOpenIssueCount == null) return [];
+  const currentOpen = state.issues.filter((i) => i.status !== "resolved").length;
+  const previous = options.previousOpenIssueCount;
+  if (previous <= 0) return [];
+  const growth = (currentOpen - previous) / previous;
+  const absolute = currentOpen - previous;
+  if (growth > DEBT_GROWTH_THRESHOLD && absolute >= DEBT_ABSOLUTE_MINIMUM) {
+    return [{
+      id: "DEBT_TREND",
+      kind: "action",
+      title: "Issue debt growing",
+      category: "debt_trend",
+      reason: `Open issues grew from ${previous} to ${currentOpen} (+${Math.round(growth * 100)}%). Consider triaging or resolving issues before adding features.`,
+      score: DEBT_TREND_SCORE
+    }];
+  }
+  return [];
+}
+var SEVERITY_RANK, PHASE_DISTANCE_PENALTY, MAX_PHASE_PENALTY, CATEGORY_PRIORITY, TICKET_ID_RE, ACTIONABLE_HEADING_RE, HANDOVER_BOOST, HANDOVER_BASE_SCORE, DEBT_TREND_SCORE, DEBT_GROWTH_THRESHOLD, DEBT_ABSOLUTE_MINIMUM;
 var init_recommend = __esm({
   "src/core/recommend.ts"() {
     "use strict";
@@ -4720,17 +4885,52 @@ var init_recommend = __esm({
       high_impact_unblock: 4,
       near_complete_umbrella: 5,
       phase_momentum: 6,
-      quick_win: 7,
-      open_issue: 8
+      debt_trend: 7,
+      quick_win: 8,
+      handover_context: 9,
+      open_issue: 10
     };
+    TICKET_ID_RE = /\bT-\d{3}[a-z]?\b/g;
+    ACTIONABLE_HEADING_RE = /^#+\s.*(next|open|remaining|todo|blocked)/im;
+    HANDOVER_BOOST = 50;
+    HANDOVER_BASE_SCORE = 350;
+    DEBT_TREND_SCORE = 450;
+    DEBT_GROWTH_THRESHOLD = 0.25;
+    DEBT_ABSOLUTE_MINIMUM = 2;
   }
 });
 
 // src/cli/commands/recommend.ts
+import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
 function handleRecommend(ctx, count) {
-  const result = recommend(ctx.state, count);
+  const options = buildRecommendOptions(ctx);
+  const result = recommend(ctx.state, count, options);
   return { output: formatRecommendations(result, ctx.state, ctx.format) };
 }
+function buildRecommendOptions(ctx) {
+  const opts = {};
+  try {
+    const files = readdirSync2(ctx.handoversDir).filter((f) => f.endsWith(".md")).sort();
+    if (files.length > 0) {
+      opts.latestHandoverContent = readFileSync2(join7(ctx.handoversDir, files[files.length - 1]), "utf-8");
+    }
+  } catch {
+  }
+  try {
+    const snapshotsDir = join7(ctx.root, ".story", "snapshots");
+    const snapFiles = readdirSync2(snapshotsDir).filter((f) => f.endsWith(".json")).sort();
+    if (snapFiles.length > 0) {
+      const raw = readFileSync2(join7(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;
+}
 var init_recommend2 = __esm({
   "src/cli/commands/recommend.ts"() {
     "use strict";
@@ -5066,6 +5266,7 @@ var init_session_types = __esm({
       "FINALIZE",
       "COMPACT",
       "LESSON_CAPTURE",
+      "ISSUE_FIX",
       "ISSUE_SWEEP"
     ]);
     IDLE_STATES = /* @__PURE__ */ new Set([
@@ -5094,6 +5295,7 @@ var init_session_types = __esm({
       "HANDOVER",
       "COMPLETE",
       "LESSON_CAPTURE",
+      "ISSUE_FIX",
       "ISSUE_SWEEP",
       "SESSION_END"
     ];
@@ -5142,6 +5344,14 @@ var init_session_types = __esm({
           timestamp: z9.string()
         })).default([])
       }).default({ plan: [], code: [] }),
+      // T-153: Current issue being fixed (null when working on a ticket)
+      currentIssue: z9.object({
+        id: z9.string(),
+        title: z9.string(),
+        severity: z9.string()
+      }).nullable().default(null),
+      // T-153: Issues resolved this session
+      resolvedIssues: z9.array(z9.string()).default([]),
       // Completed tickets this session
       completedTickets: z9.array(z9.object({
         id: z9.string(),
@@ -5280,27 +5490,27 @@ __export(session_exports, {
 import { randomUUID } from "crypto";
 import {
   mkdirSync,
-  readdirSync,
-  readFileSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync3,
   writeFileSync,
   renameSync,
   unlinkSync,
   existsSync as existsSync6,
   rmSync
 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import lockfile2 from "proper-lockfile";
 function sessionsRoot(root) {
-  return join6(root, ".story", SESSIONS_DIR);
+  return join8(root, ".story", SESSIONS_DIR);
 }
 function sessionDir(root, sessionId) {
-  return join6(sessionsRoot(root), sessionId);
+  return join8(sessionsRoot(root), sessionId);
 }
 function statePath(dir) {
-  return join6(dir, "state.json");
+  return join8(dir, "state.json");
 }
 function eventsPath(dir) {
-  return join6(dir, "events.log");
+  return join8(dir, "events.log");
 }
 function createSession(root, recipe, workspaceId, configOverrides) {
   const id = randomUUID();
@@ -5356,7 +5566,7 @@ function readSession(dir) {
   const path2 = statePath(dir);
   let raw;
   try {
-    raw = readFileSync(path2, "utf-8");
+    raw = readFileSync3(path2, "utf-8");
   } catch {
     return null;
   }
@@ -5399,7 +5609,7 @@ function readEvents(dir) {
   const path2 = eventsPath(dir);
   let raw;
   try {
-    raw = readFileSync(path2, "utf-8");
+    raw = readFileSync3(path2, "utf-8");
   } catch {
     return { events: [], malformedCount: 0 };
   }
@@ -5456,7 +5666,7 @@ function findActiveSessionFull(root) {
   const sessDir = sessionsRoot(root);
   let entries;
   try {
-    entries = readdirSync(sessDir, { withFileTypes: true });
+    entries = readdirSync3(sessDir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -5470,7 +5680,7 @@ function findActiveSessionFull(root) {
   let bestGuideCall = 0;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = join6(sessDir, entry.name);
+    const dir = join8(sessDir, entry.name);
     const session = readSession(dir);
     if (!session) continue;
     if (session.status !== "active") continue;
@@ -5493,7 +5703,7 @@ function findStaleSessions(root) {
   const sessDir = sessionsRoot(root);
   let entries;
   try {
-    entries = readdirSync(sessDir, { withFileTypes: true });
+    entries = readdirSync3(sessDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -5506,7 +5716,7 @@ function findStaleSessions(root) {
   const results = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = join6(sessDir, entry.name);
+    const dir = join8(sessDir, entry.name);
     const session = readSession(dir);
     if (!session) continue;
     if (session.status !== "active") continue;
@@ -5562,7 +5772,7 @@ function findResumableSession(root) {
   const sessDir = sessionsRoot(root);
   let entries;
   try {
-    entries = readdirSync(sessDir, { withFileTypes: true });
+    entries = readdirSync3(sessDir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -5577,7 +5787,7 @@ function findResumableSession(root) {
   let bestPreparedAt = 0;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const dir = join6(sessDir, entry.name);
+    const dir = join8(sessDir, entry.name);
     const session = readSession(dir);
     if (!session) continue;
     if (session.status !== "active") continue;
@@ -5601,7 +5811,7 @@ async function withSessionLock(root, fn) {
     release = await lockfile2.lock(sessDir, {
       retries: { retries: 3, minTimeout: 100, maxTimeout: 1e3 },
       stale: 3e4,
-      lockfilePath: join6(sessDir, ".lock")
+      lockfilePath: join8(sessDir, ".lock")
     });
     return await fn();
   } finally {
@@ -5645,7 +5855,7 @@ var init_state_machine = __esm({
       // start does INIT + LOAD_CONTEXT internally
       LOAD_CONTEXT: ["PICK_TICKET"],
       // internal (never seen by Claude)
-      PICK_TICKET: ["PLAN", "SESSION_END"],
+      PICK_TICKET: ["PLAN", "ISSUE_FIX", "SESSION_END"],
       PLAN: ["PLAN_REVIEW"],
       PLAN_REVIEW: ["IMPLEMENT", "WRITE_TESTS", "PLAN", "PLAN_REVIEW", "SESSION_END"],
       // approve → IMPLEMENT/WRITE_TESTS, reject → PLAN, stay for next round; SESSION_END for tiered exit
@@ -5659,8 +5869,11 @@ var init_state_machine = __esm({
       // approve → VERIFY/FINALIZE, reject → IMPLEMENT/PLAN, stay for next round; SESSION_END for tiered exit
       VERIFY: ["FINALIZE", "IMPLEMENT", "VERIFY"],
       // pass → FINALIZE, fail → IMPLEMENT, retry
-      FINALIZE: ["COMPLETE"],
+      FINALIZE: ["COMPLETE", "PICK_TICKET"],
+      // PICK_TICKET for issue-fix flow (bypass COMPLETE)
       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
       LESSON_CAPTURE: ["ISSUE_SWEEP", "HANDOVER", "LESSON_CAPTURE"],
       // advance → ISSUE_SWEEP, retry self, done → HANDOVER
       ISSUE_SWEEP: ["ISSUE_SWEEP", "HANDOVER", "PICK_TICKET"],
@@ -5917,16 +6130,16 @@ var init_git_inspector = __esm({
 });
 
 // src/autonomous/recipes/loader.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join9, 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 = join7(dirname3(fileURLToPath2(import.meta.url)), "..", "recipes");
-  const path2 = join7(recipesDir, `${recipeName}.json`);
-  const raw = readFileSync2(path2, "utf-8");
+  const recipesDir = join9(dirname3(fileURLToPath2(import.meta.url)), "..", "recipes");
+  const path2 = join9(recipesDir, `${recipeName}.json`);
+  const raw = readFileSync4(path2, "utf-8");
   return JSON.parse(raw);
 }
 function resolveRecipe(recipeName, projectOverrides) {
@@ -6202,7 +6415,7 @@ var init_types2 = __esm({
 
 // src/autonomous/stages/pick-ticket.ts
 import { existsSync as existsSync7, unlinkSync as unlinkSync2 } from "fs";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 var PickTicketStage;
 var init_pick_ticket = __esm({
   "src/autonomous/stages/pick-ticket.ts"() {
@@ -6220,28 +6433,52 @@ var init_pick_ticket = __esm({
             (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type})`
           ).join("\n");
         }
+        const highIssues = projectState.issues.filter(
+          (i) => i.status === "open" && (i.severity === "critical" || i.severity === "high")
+        );
+        let issuesText = "";
+        if (highIssues.length > 0) {
+          issuesText = "\n\n## Open Issues (high+ severity)\n\n" + highIssues.map(
+            (i, idx) => `${idx + 1}. **${i.id}: ${i.title}** (${i.severity})`
+          ).join("\n");
+        }
         const topCandidate = candidates.kind === "found" ? candidates.candidates[0] : null;
+        const hasIssues = highIssues.length > 0;
         return {
           instruction: [
-            "# Pick a Ticket",
+            "# Pick a Ticket or Issue",
+            "",
+            "## Ticket Candidates",
             "",
             candidatesText || "No ticket candidates found.",
+            issuesText,
             "",
-            topCandidate ? `Pick **${topCandidate.ticket.id}** (highest priority) by calling \`claudestory_autonomous_guide\` now:` : "Pick a ticket by calling `claudestory_autonomous_guide` now:",
+            topCandidate ? `Pick **${topCandidate.ticket.id}** (highest priority) or an open issue by calling \`claudestory_autonomous_guide\` now:` : hasIssues ? `Pick an issue to fix by calling \`claudestory_autonomous_guide\` now:` : "Pick a ticket by calling `claudestory_autonomous_guide` now:",
             "```json",
             topCandidate ? `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "${topCandidate.ticket.id}" } }` : `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "T-XXX" } }`,
-            "```"
+            "```",
+            ...hasIssues ? [
+              "",
+              "Or to fix an issue:",
+              "```json",
+              `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "issue_picked", "issueId": "${highIssues[0].id}" } }`,
+              "```"
+            ] : []
           ].join("\n"),
           reminders: [
-            "Do NOT stop or summarize. Call autonomous_guide IMMEDIATELY to pick a ticket.",
+            "Do NOT stop or summarize. Call autonomous_guide IMMEDIATELY to pick a ticket or issue.",
             "Do NOT ask the user for confirmation."
           ]
         };
       }
       async report(ctx, report) {
+        const issueId = report.issueId;
+        if (issueId) {
+          return this.handleIssuePick(ctx, issueId);
+        }
         const ticketId = report.ticketId;
         if (!ticketId) {
-          return { action: "retry", instruction: "report.ticketId is required when picking a ticket." };
+          return { action: "retry", instruction: "report.ticketId or report.issueId is required." };
         }
         const { state: projectState } = await ctx.loadProject();
         const ticket = projectState.ticketByID(ticketId);
@@ -6257,7 +6494,7 @@ var init_pick_ticket = __esm({
             return { action: "retry", instruction: `Ticket ${ticketId} is ${ticket.status} \u2014 pick an open ticket.` };
           }
         }
-        const planPath = join8(ctx.dir, "plan.md");
+        const planPath = join10(ctx.dir, "plan.md");
         try {
           if (existsSync7(planPath)) unlinkSync2(planPath);
         } catch {
@@ -6292,16 +6529,34 @@ ${ticket.description}` : "",
           }
         };
       }
+      // T-153: Handle issue pick -- validate and route to ISSUE_FIX
+      async handleIssuePick(ctx, issueId) {
+        const { state: projectState } = await ctx.loadProject();
+        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.` };
+        }
+        if (issue.status !== "open") {
+          return { action: "retry", instruction: `Issue ${issueId} is ${issue.status}. Pick an open issue.` };
+        }
+        ctx.updateDraft({
+          currentIssue: { id: issue.id, title: issue.title, severity: issue.severity },
+          ticket: void 0,
+          reviews: { plan: [], code: [] },
+          finalizeCheckpoint: null
+        });
+        return { action: "goto", target: "ISSUE_FIX" };
+      }
     };
   }
 });
 
 // src/autonomous/stages/plan.ts
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join11 } from "path";
 function readFileSafe(path2) {
   try {
-    return readFileSync3(path2, "utf-8");
+    return readFileSync5(path2, "utf-8");
   } catch {
     return "";
   }
@@ -6342,7 +6597,7 @@ var init_plan = __esm({
         };
       }
       async report(ctx, _report) {
-        const planPath = join9(ctx.dir, "plan.md");
+        const planPath = join11(ctx.dir, "plan.md");
         if (!existsSync8(planPath)) {
           return { action: "retry", instruction: `Plan file not found at ${planPath}. Write your plan there and call me again.`, reminders: ["Save plan to .story/sessions/<id>/plan.md"] };
         }
@@ -6588,7 +6843,8 @@ var init_implement = __esm({
           reminders: [
             "Follow the plan exactly. Do NOT deviate without re-planning.",
             "Do NOT ask the user for confirmation.",
-            "If you discover pre-existing bugs, failing tests not caused by your changes, or other out-of-scope problems, file them as issues using claudestory_issue_create. Do not fix them inline."
+            "If you discover pre-existing bugs, failing tests not caused by your changes, or other out-of-scope problems, file them as issues using claudestory_issue_create. Do not fix them inline.",
+            "Track which files you create or modify. Only these files should be staged at commit time."
           ],
           transitionedFrom: ctx.state.previousState ?? void 0
         };
@@ -7285,10 +7541,13 @@ var init_finalize = __esm({
             "Code review passed. Time to commit.",
             "",
             ctx.state.ticket ? `1. Update ticket ${ctx.state.ticket.id} status to "complete" in .story/` : "",
-            "2. Stage all changed files (code + .story/ changes)",
+            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"'
           ].filter(Boolean).join("\n"),
-          reminders: ["Stage both code changes and .story/ ticket update in the same commit."],
+          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."
+          ],
           transitionedFrom: ctx.state.previousState ?? void 0
         };
       }
@@ -7331,9 +7590,9 @@ var init_finalize = __esm({
           const headResult = await gitHead(ctx.root);
           const previousHead = ctx.state.git.expectedHead ?? ctx.state.git.initHead;
           if (headResult.ok && previousHead && headResult.data.hash !== previousHead) {
+            const treeResult = await gitDiffTreeNames(ctx.root, headResult.data.hash);
             const ticketId2 = ctx.state.ticket?.id;
             if (ticketId2) {
-              const treeResult = await gitDiffTreeNames(ctx.root, headResult.data.hash);
               const ticketPath = `.story/tickets/${ticketId2}.json`;
               if (treeResult.ok && !treeResult.data.includes(ticketPath)) {
                 return {
@@ -7342,6 +7601,16 @@ var init_finalize = __esm({
                 };
               }
             }
+            const earlyIssueId = ctx.state.currentIssue?.id;
+            if (earlyIssueId) {
+              const issuePath = `.story/issues/${earlyIssueId}.json`;
+              if (treeResult.ok && !treeResult.data.includes(issuePath)) {
+                return {
+                  action: "retry",
+                  instruction: `Commit detected (${headResult.data.hash.slice(0, 7)}) but issue file ${issuePath} is not in the commit. Amend the commit to include it: \`git add ${issuePath} && git commit --amend --no-edit\`, then report completedAction: "commit_done" with the new hash.`
+                };
+              }
+            }
             ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
             return this.handleCommit(ctx, { ...report, commitHash: headResult.data.hash });
           }
@@ -7375,6 +7644,16 @@ var init_finalize = __esm({
             };
           }
         }
+        const issueId = ctx.state.currentIssue?.id;
+        if (issueId) {
+          const issuePath = `.story/issues/${issueId}.json`;
+          if (!stagedResult.data.includes(issuePath)) {
+            return {
+              action: "retry",
+              instruction: `Issue file ${issuePath} is not staged. Run \`git add ${issuePath}\` and call me again with completedAction: "files_staged".`
+            };
+          }
+        }
         ctx.writeState({
           finalizeCheckpoint: overlapOverridden ? "staged_override" : "staged"
         });
@@ -7422,6 +7701,16 @@ var init_finalize = __esm({
             };
           }
         }
+        const precommitIssueId = ctx.state.currentIssue?.id;
+        if (precommitIssueId) {
+          const issuePath = `.story/issues/${precommitIssueId}.json`;
+          if (!stagedResult.data.includes(issuePath)) {
+            return {
+              action: "retry",
+              instruction: `Pre-commit hooks may have modified the staged set. Issue file ${issuePath} is no longer staged. Run \`git add ${issuePath}\` and call me again with completedAction: "files_staged".`
+            };
+          }
+        }
         ctx.writeState({ finalizeCheckpoint: "precommit_passed" });
         return {
           action: "retry",
@@ -7459,6 +7748,21 @@ var init_finalize = __esm({
         if (previousHead && normalizedHash === previousHead) {
           return { action: "retry", instruction: `No new commit detected: HEAD (${normalizedHash}) has not changed. Create a commit first, then report the new hash.` };
         }
+        const currentIssue = ctx.state.currentIssue;
+        if (currentIssue) {
+          ctx.writeState({
+            finalizeCheckpoint: "committed",
+            resolvedIssues: [...ctx.state.resolvedIssues ?? [], currentIssue.id],
+            currentIssue: null,
+            git: {
+              ...ctx.state.git,
+              mergeBase: normalizedHash,
+              expectedHead: normalizedHash
+            }
+          });
+          ctx.appendEvent("commit", { commitHash: normalizedHash, issueId: currentIssue.id });
+          return { action: "goto", target: "PICK_TICKET" };
+        }
         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;
         ctx.writeState({
           finalizeCheckpoint: "committed",
@@ -7683,6 +7987,85 @@ var init_lesson_capture = __esm({
   }
 });
 
+// src/autonomous/stages/issue-fix.ts
+var IssueFixStage;
+var init_issue_fix = __esm({
+  "src/autonomous/stages/issue-fix.ts"() {
+    "use strict";
+    init_esm_shims();
+    IssueFixStage = class {
+      id = "ISSUE_FIX";
+      async enter(ctx) {
+        const issue = ctx.state.currentIssue;
+        if (!issue) {
+          return { action: "goto", target: "PICK_TICKET" };
+        }
+        const { state: projectState } = await ctx.loadProject();
+        const fullIssue = projectState.issues.find((i) => i.id === issue.id);
+        const details = fullIssue ? [
+          `**${fullIssue.id}**: ${fullIssue.title}`,
+          "",
+          `Severity: ${fullIssue.severity}`,
+          fullIssue.impact ? `Impact: ${fullIssue.impact}` : "",
+          fullIssue.components.length > 0 ? `Components: ${fullIssue.components.join(", ")}` : "",
+          fullIssue.location.length > 0 ? `Location: ${fullIssue.location.join(", ")}` : ""
+        ].filter(Boolean).join("\n") : `**${issue.id}**: ${issue.title} (severity: ${issue.severity})`;
+        return {
+          instruction: [
+            "# Fix Issue",
+            "",
+            details,
+            "",
+            '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."
+          ]
+        };
+      }
+      async report(ctx, _report) {
+        const issue = ctx.state.currentIssue;
+        if (!issue) {
+          return { action: "goto", target: "PICK_TICKET" };
+        }
+        const { state: projectState } = await ctx.loadProject();
+        const current = projectState.issues.find((i) => i.id === issue.id);
+        if (!current || current.status !== "resolved") {
+          return {
+            action: "retry",
+            instruction: `Issue ${issue.id} is still ${current?.status ?? "missing"}. Update its status to "resolved" in .story/issues/${issue.id}.json with a resolution description and resolvedDate, then report again.`,
+            reminders: ["Set status to 'resolved', add resolution text, set resolvedDate."]
+          };
+        }
+        return {
+          action: "goto",
+          target: "FINALIZE",
+          result: {
+            instruction: [
+              "# Finalize Issue Fix",
+              "",
+              `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"'
+            ].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"
+          }
+        };
+      }
+    };
+  }
+});
+
 // src/autonomous/stages/issue-sweep.ts
 var IssueSweepStage;
 var init_issue_sweep = __esm({
@@ -7792,7 +8175,7 @@ Impact: ${nextIssue.impact}` : ""}` : `Fix issue ${next}.`,
 
 // src/autonomous/stages/handover.ts
 import { writeFileSync as writeFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 var HandoverStage;
 var init_handover2 = __esm({
   "src/autonomous/stages/handover.ts"() {
@@ -7829,7 +8212,7 @@ var init_handover2 = __esm({
         } catch {
           handoverFailed = true;
           try {
-            const fallbackPath = join10(ctx.dir, "handover-fallback.md");
+            const fallbackPath = join12(ctx.dir, "handover-fallback.md");
             writeFileSync2(fallbackPath, content, "utf-8");
           } catch {
           }
@@ -7893,6 +8276,7 @@ var init_stages = __esm({
     init_finalize();
     init_complete();
     init_lesson_capture();
+    init_issue_fix();
     init_issue_sweep();
     init_handover2();
     registerStage(new PickTicketStage());
@@ -7907,14 +8291,39 @@ var init_stages = __esm({
     registerStage(new FinalizeStage());
     registerStage(new CompleteStage());
     registerStage(new LessonCaptureStage());
+    registerStage(new IssueFixStage());
     registerStage(new IssueSweepStage());
     registerStage(new HandoverStage());
   }
 });
 
 // src/autonomous/guide.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "fs";
+import { join as join13 } from "path";
+function buildGuideRecommendOptions(root) {
+  const opts = {};
+  try {
+    const handoversDir = join13(root, ".story", "handovers");
+    const files = readdirSync4(handoversDir, "utf-8").filter((f) => f.endsWith(".md")).sort();
+    if (files.length > 0) {
+      opts.latestHandoverContent = readFileSync6(join13(handoversDir, files[files.length - 1]), "utf-8");
+    }
+  } catch {
+  }
+  try {
+    const snapshotsDir = join13(root, ".story", "snapshots");
+    const snapFiles = readdirSync4(snapshotsDir, "utf-8").filter((f) => f.endsWith(".json")).sort();
+    if (snapFiles.length > 0) {
+      const raw = readFileSync6(join13(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 recoverPendingMutation(dir, state, root) {
   const mutation = state.pendingProjectMutation;
   if (!mutation || typeof mutation !== "object") return state;
@@ -8286,7 +8695,7 @@ Staged: ${stagedResult.data.join(", ")}`
       }
     }
     const { state: projectState, warnings } = await loadProject(root);
-    const handoversDir = join11(root, ".story", "handovers");
+    const handoversDir = join13(root, ".story", "handovers");
     const ctx = { state: projectState, warnings, root, handoversDir, format: "md" };
     let handoverText = "";
     try {
@@ -8303,7 +8712,7 @@ Staged: ${stagedResult.data.join(", ")}`
       }
     } catch {
     }
-    const rulesText = readFileSafe2(join11(root, "RULES.md"));
+    const rulesText = readFileSafe2(join13(root, "RULES.md"));
     const lessonDigest = buildLessonDigest(projectState.lessons);
     const digestParts = [
       handoverText ? `## Recent Handovers
@@ -8319,7 +8728,7 @@ ${rulesText}` : "",
     ].filter(Boolean);
     const digest = digestParts.join("\n\n---\n\n");
     try {
-      writeFileSync3(join11(dir, "context-digest.md"), digest, "utf-8");
+      writeFileSync3(join13(dir, "context-digest.md"), digest, "utf-8");
     } catch {
     }
     if (mode !== "auto" && args.ticketId) {
@@ -8338,6 +8747,18 @@ ${rulesText}` : "",
           return guideError(new Error(`Ticket ${args.ticketId} is blocked by: ${ticket.blockedBy.join(", ")}.`));
         }
       }
+      if (mode !== "review") {
+        const claimId = ticket.claimedBySession;
+        if (claimId && typeof claimId === "string" && claimId !== session.sessionId) {
+          const claimingSession = findSessionById(root, claimId);
+          if (claimingSession && claimingSession.state.status === "active" && !isLeaseExpired(claimingSession.state)) {
+            deleteSession(root, session.sessionId);
+            return guideError(new Error(
+              `Ticket ${args.ticketId} is claimed by active session ${claimId}. Wait for it to finish or stop it with "claudestory session stop ${claimId}".`
+            ));
+          }
+        }
+      }
       let entryState;
       if (mode === "review") {
         entryState = "CODE_REVIEW";
@@ -8433,12 +8854,22 @@ ${ticket.description}` : "",
     } else {
       candidatesText = "No tickets found.";
     }
-    const recResult = recommend(projectState, 5);
+    const highIssues = projectState.issues.filter(
+      (i) => i.status === "open" && (i.severity === "critical" || i.severity === "high")
+    );
+    let issuesText = "";
+    if (highIssues.length > 0) {
+      issuesText = "\n\n## Open Issues (high+ severity)\n\n" + highIssues.map(
+        (i, idx) => `${idx + 1}. **${i.id}: ${i.title}** (${i.severity})`
+      ).join("\n");
+    }
+    const guideRecOptions = buildGuideRecommendOptions(root);
+    const recResult = recommend(projectState, 5, guideRecOptions);
     let recsText = "";
     if (recResult.recommendations.length > 0) {
-      const ticketRecs = recResult.recommendations.filter((r) => r.kind === "ticket");
-      if (ticketRecs.length > 0) {
-        recsText = "\n\n**Recommended:**\n" + ticketRecs.map(
+      const actionableRecs = recResult.recommendations.filter((r) => r.kind === "ticket" || r.kind === "issue");
+      if (actionableRecs.length > 0) {
+        recsText = "\n\n**Recommended:**\n" + actionableRecs.map(
           (r) => `- ${r.id}: ${r.title} (${r.reason})`
         ).join("\n");
       }
@@ -8458,21 +8889,30 @@ ${ticket.description}` : "",
     const interval = updated.config.handoverInterval ?? 3;
     const sessionDesc = maxTickets > 0 ? `Work continuously until all tickets are done or you reach ${maxTickets} tickets.` : "Work continuously until all tickets are done.";
     const checkpointDesc = interval > 0 ? ` A checkpoint handover will be saved every ${interval} tickets.` : "";
+    const hasHighIssues = highIssues.length > 0;
     const instruction = [
       "# Autonomous Session Started",
       "",
       `You are now in autonomous mode. ${sessionDesc}${checkpointDesc}`,
-      "Do NOT stop to summarize. Do NOT ask the user. Pick a ticket and start working immediately.",
+      "Do NOT stop to summarize. Do NOT ask the user. Pick a ticket or issue and start working immediately.",
       "",
       "## Ticket Candidates",
       "",
       candidatesText,
+      issuesText,
       recsText,
       "",
-      topCandidate ? `Pick **${topCandidate.ticket.id}** (highest priority) by calling \`claudestory_autonomous_guide\` now:` : "Pick a ticket by calling `claudestory_autonomous_guide` now:",
+      topCandidate ? `Pick **${topCandidate.ticket.id}** (highest priority) or an open issue by calling \`claudestory_autonomous_guide\` now:` : hasHighIssues ? "Pick an issue to fix by calling `claudestory_autonomous_guide` now:" : "Pick a ticket by calling `claudestory_autonomous_guide` now:",
       "```json",
       topCandidate ? `{ "sessionId": "${updated.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "${topCandidate.ticket.id}" } }` : `{ "sessionId": "${updated.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "T-XXX" } }`,
-      "```"
+      "```",
+      ...hasHighIssues ? [
+        "",
+        "Or to fix an issue:",
+        "```json",
+        `{ "sessionId": "${updated.sessionId}", "action": "report", "report": { "completedAction": "issue_picked", "issueId": "${highIssues[0].id}" } }`,
+        "```"
+      ] : []
     ].join("\n");
     return guideResult(updated, "PICK_TICKET", {
       instruction,
@@ -8658,26 +9098,7 @@ async function handleResume(root, args) {
     ));
   }
   if (expectedHead && headResult.data.hash !== expectedHead) {
-    const recoveryMapping = {
-      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 },
-      // T-139: baseline stale after HEAD change
-      VERIFY: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
-      // T-131: reviewed code stale after HEAD drift
-      PLAN_REVIEW: { state: "PLAN", resetPlan: true, resetCode: true },
-      TEST: { state: "IMPLEMENT", resetPlan: false, resetCode: true },
-      // T-128: tests invalidated by HEAD change
-      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_SWEEP: { state: "PICK_TICKET", resetPlan: false, resetCode: false }
-      // T-128: post-complete, restart sweep
-    };
-    const mapping = recoveryMapping[resumeState] ?? { state: "PICK_TICKET", resetPlan: false, resetCode: false };
+    const mapping = RECOVERY_MAPPING[resumeState] ?? { state: "PICK_TICKET", resetPlan: false, resetCode: false };
     const recoveryReviews = {
       plan: mapping.resetPlan ? [] : info.state.reviews.plan,
       code: mapping.resetCode ? [] : info.state.reviews.code
@@ -9025,12 +9446,12 @@ function guideError(err) {
 }
 function readFileSafe2(path2) {
   try {
-    return readFileSync4(path2, "utf-8");
+    return readFileSync6(path2, "utf-8");
   } catch {
     return "";
   }
 }
-var SEVERITY_MAP, workspaceLocks, MAX_AUTO_ADVANCE_DEPTH;
+var RECOVERY_MAPPING, SEVERITY_MAP, workspaceLocks, MAX_AUTO_ADVANCE_DEPTH;
 var init_guide = __esm({
   "src/autonomous/guide.ts"() {
     "use strict";
@@ -9052,6 +9473,23 @@ var init_guide = __esm({
     init_queries();
     init_recommend();
     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",
@@ -9260,8 +9698,8 @@ var init_session_report_formatter = __esm({
 });
 
 // src/cli/commands/session-report.ts
-import { readFileSync as readFileSync5, existsSync as existsSync10 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync10 } from "fs";
+import { join as join14 } from "path";
 async function handleSessionReport(sessionId, root, format = "md") {
   if (!UUID_REGEX.test(sessionId)) {
     return {
@@ -9280,7 +9718,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
       isError: true
     };
   }
-  const statePath2 = join12(dir, "state.json");
+  const statePath2 = join14(dir, "state.json");
   if (!existsSync10(statePath2)) {
     return {
       output: `Error: Session ${sessionId} corrupt \u2014 state.json missing.`,
@@ -9290,7 +9728,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
     };
   }
   try {
-    const rawJson = JSON.parse(readFileSync5(statePath2, "utf-8"));
+    const rawJson = JSON.parse(readFileSync7(statePath2, "utf-8"));
     if (rawJson && typeof rawJson === "object" && "schemaVersion" in rawJson && rawJson.schemaVersion !== CURRENT_SESSION_SCHEMA_VERSION) {
       return {
         output: `Error: Session ${sessionId} \u2014 unsupported session schema version ${rawJson.schemaVersion}.`,
@@ -9319,7 +9757,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
   const events = readEvents(dir);
   let planContent = null;
   try {
-    planContent = readFileSync5(join12(dir, "plan.md"), "utf-8");
+    planContent = readFileSync7(join14(dir, "plan.md"), "utf-8");
   } catch {
   }
   let gitLog = null;
@@ -9348,7 +9786,7 @@ var init_session_report = __esm({
 });
 
 // src/cli/commands/phase.ts
-import { join as join13, resolve as resolve6 } from "path";
+import { join as join15, resolve as resolve6 } 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`);
@@ -9537,21 +9975,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 = join13(wrapDir, "tickets", `${parsed.id}.json`);
+        const target = join15(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 = join13(wrapDir, "issues", `${parsed.id}.json`);
+        const target = join15(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 = join13(wrapDir, "roadmap.json");
+      const roadmapTarget = join15(wrapDir, "roadmap.json");
       operations.push({ op: "write", target: roadmapTarget, content: roadmapContent });
       await runTransactionUnlocked(root, operations);
     } else {
@@ -9584,14 +10022,14 @@ var init_phase = __esm({
 
 // src/mcp/tools.ts
 import { z as z10 } from "zod";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 function formatMcpError(code, message) {
   return `[${code}] ${message}`;
 }
 async function runMcpReadTool(pinnedRoot, handler) {
   try {
     const { state, warnings } = await loadProject(pinnedRoot);
-    const handoversDir = join14(pinnedRoot, ".story", "handovers");
+    const handoversDir = join16(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)) {
@@ -10178,10 +10616,10 @@ var init_tools = __esm({
 
 // src/core/init.ts
 import { mkdir as mkdir4, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join15, resolve as resolve7 } from "path";
+import { join as join17, resolve as resolve7 } from "path";
 async function initProject(root, options) {
   const absRoot = resolve7(root);
-  const wrapDir = join15(absRoot, ".story");
+  const wrapDir = join17(absRoot, ".story");
   let exists = false;
   try {
     const s = await stat2(wrapDir);
@@ -10201,11 +10639,11 @@ async function initProject(root, options) {
       ".story/ already exists. Use --force to overwrite config and roadmap."
     );
   }
-  await mkdir4(join15(wrapDir, "tickets"), { recursive: true });
-  await mkdir4(join15(wrapDir, "issues"), { recursive: true });
-  await mkdir4(join15(wrapDir, "handovers"), { recursive: true });
-  await mkdir4(join15(wrapDir, "notes"), { recursive: true });
-  await mkdir4(join15(wrapDir, "lessons"), { recursive: true });
+  await mkdir4(join17(wrapDir, "tickets"), { recursive: true });
+  await mkdir4(join17(wrapDir, "issues"), { recursive: true });
+  await mkdir4(join17(wrapDir, "handovers"), { recursive: true });
+  await mkdir4(join17(wrapDir, "notes"), { recursive: true });
+  await mkdir4(join17(wrapDir, "lessons"), { recursive: true });
   const created = [
     ".story/config.json",
     ".story/roadmap.json",
@@ -10245,7 +10683,7 @@ async function initProject(root, options) {
   };
   await writeConfig(config, absRoot);
   await writeRoadmap(roadmap, absRoot);
-  const gitignorePath = join15(wrapDir, ".gitignore");
+  const gitignorePath = join17(wrapDir, ".gitignore");
   await ensureGitignoreEntries(gitignorePath, STORY_GITIGNORE_ENTRIES);
   const warnings = [];
   if (options.force && exists) {
@@ -10293,7 +10731,7 @@ var init_init = __esm({
 // src/mcp/index.ts
 var mcp_exports = {};
 import { realpathSync as realpathSync2, existsSync as existsSync11 } from "fs";
-import { resolve as resolve8, join as join16, isAbsolute } from "path";
+import { resolve as resolve8, join as join18, isAbsolute } from "path";
 import { z as z11 } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -10308,7 +10746,7 @@ function tryDiscoverRoot() {
     const resolved = resolve8(envRoot);
     try {
       const canonical = realpathSync2(resolved);
-      if (existsSync11(join16(canonical, CONFIG_PATH2))) {
+      if (existsSync11(join18(canonical, CONFIG_PATH2))) {
         return canonical;
       }
       process.stderr.write(`Warning: No .story/config.json at ${canonical}
@@ -10411,7 +10849,7 @@ var init_mcp = __esm({
     init_init();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.35";
+    version = "0.1.37";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -10447,7 +10885,7 @@ __export(run_exports, {
   runReadCommand: () => runReadCommand,
   writeOutput: () => writeOutput
 });
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function writeOutput(text) {
   try {
     process.stdout.write(text + "\n");
@@ -10475,7 +10913,7 @@ async function runReadCommand(format, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join17(root, ".story", "handovers");
+    const handoversDir = join19(root, ".story", "handovers");
     const result = await handler({ state, warnings, root, handoversDir, format });
     writeOutput(result.output);
     let exitCode = result.exitCode ?? ExitCode.OK;
@@ -10510,7 +10948,7 @@ async function runDeleteCommand(format, force, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join17(root, ".story", "handovers");
+    const handoversDir = join19(root, ".story", "handovers");
     if (!force && hasIntegrityWarnings(warnings)) {
       writeOutput(
         formatError(
@@ -11024,7 +11462,7 @@ __export(setup_skill_exports, {
 });
 import { mkdir as mkdir5, writeFile as writeFile3, readFile as readFile5, rm, rename as rename2, unlink as unlink3 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join18, dirname as dirname4 } from "path";
+import { join as join20, dirname as dirname4 } from "path";
 import { homedir } from "os";
 import { execFileSync } from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -11033,10 +11471,10 @@ function log(msg) {
 }
 function resolveSkillSourceDir() {
   const thisDir = dirname4(fileURLToPath3(import.meta.url));
-  const bundledPath = join18(thisDir, "..", "src", "skill");
-  if (existsSync12(join18(bundledPath, "SKILL.md"))) return bundledPath;
-  const sourcePath = join18(thisDir, "..", "..", "skill");
-  if (existsSync12(join18(sourcePath, "SKILL.md"))) return sourcePath;
+  const bundledPath = join20(thisDir, "..", "src", "skill");
+  if (existsSync12(join20(bundledPath, "SKILL.md"))) return bundledPath;
+  const sourcePath = join20(thisDir, "..", "..", "skill");
+  if (existsSync12(join20(sourcePath, "SKILL.md"))) return sourcePath;
   throw new Error(
     `Cannot find bundled skill files. Checked:
   ${bundledPath}
@@ -11049,7 +11487,7 @@ 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 ?? join18(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join20(homedir(), ".claude", "settings.json");
   let raw = "{}";
   if (existsSync12(path2)) {
     try {
@@ -11147,7 +11585,7 @@ 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 ?? join18(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join20(homedir(), ".claude", "settings.json");
   let raw = "{}";
   if (existsSync12(path2)) {
     try {
@@ -11194,7 +11632,7 @@ async function removeHook(hookType, command, settingsPath) {
 }
 async function handleSetupSkill(options = {}) {
   const { skipHooks = false } = options;
-  const skillDir = join18(homedir(), ".claude", "skills", "story");
+  const skillDir = join20(homedir(), ".claude", "skills", "story");
   await mkdir5(skillDir, { recursive: true });
   let srcSkillDir;
   try {
@@ -11207,19 +11645,19 @@ async function handleSetupSkill(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const oldPrimeDir = join18(homedir(), ".claude", "skills", "prime");
+  const oldPrimeDir = join20(homedir(), ".claude", "skills", "prime");
   if (existsSync12(oldPrimeDir)) {
     await rm(oldPrimeDir, { recursive: true, force: true });
     log("Removed old /prime skill (migrated to /story)");
   }
-  const existed = existsSync12(join18(skillDir, "SKILL.md"));
-  const skillContent = await readFile5(join18(srcSkillDir, "SKILL.md"), "utf-8");
-  await writeFile3(join18(skillDir, "SKILL.md"), skillContent, "utf-8");
+  const existed = existsSync12(join20(skillDir, "SKILL.md"));
+  const skillContent = await readFile5(join20(srcSkillDir, "SKILL.md"), "utf-8");
+  await writeFile3(join20(skillDir, "SKILL.md"), skillContent, "utf-8");
   let referenceWritten = false;
-  const refSrcPath = join18(srcSkillDir, "reference.md");
+  const refSrcPath = join20(srcSkillDir, "reference.md");
   if (existsSync12(refSrcPath)) {
     const refContent = await readFile5(refSrcPath, "utf-8");
-    await writeFile3(join18(skillDir, "reference.md"), refContent, "utf-8");
+    await writeFile3(join20(skillDir, "reference.md"), refContent, "utf-8");
     referenceWritten = true;
   }
   log(`${existed ? "Updated" : "Installed"} /story skill at ${skillDir}/`);
@@ -11333,8 +11771,8 @@ var hook_status_exports = {};
 __export(hook_status_exports, {
   handleHookStatus: () => handleHookStatus
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync4 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync4 } from "fs";
+import { join as join21 } from "path";
 async function readStdinSilent() {
   try {
     const chunks = [];
@@ -11384,10 +11822,10 @@ function activePayload(session) {
   };
 }
 function ensureGitignore(root) {
-  const gitignorePath = join19(root, ".story", ".gitignore");
+  const gitignorePath = join21(root, ".story", ".gitignore");
   let existing = "";
   try {
-    existing = readFileSync6(gitignorePath, "utf-8");
+    existing = readFileSync8(gitignorePath, "utf-8");
   } catch {
   }
   const lines = existing.split("\n").map((l) => l.trim());
@@ -11403,7 +11841,7 @@ function ensureGitignore(root) {
 }
 function writeStatus(root, payload) {
   ensureGitignore(root);
-  const statusPath = join19(root, ".story", "status.json");
+  const statusPath = join21(root, ".story", "status.json");
   const content = JSON.stringify(payload, null, 2) + "\n";
   atomicWriteSync(statusPath, content);
 }
@@ -11462,8 +11900,8 @@ var config_update_exports = {};
 __export(config_update_exports, {
   handleConfigSetOverrides: () => handleConfigSetOverrides
 });
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join22 } from "path";
 async function handleConfigSetOverrides(root, format, options) {
   const { json: jsonArg, clear } = options;
   if (!clear && !jsonArg) {
@@ -11491,8 +11929,8 @@ async function handleConfigSetOverrides(root, format, options) {
   }
   let resultOverrides = null;
   await withProjectLock(root, { strict: false }, async () => {
-    const configPath = join20(root, ".story", "config.json");
-    const rawContent = readFileSync7(configPath, "utf-8");
+    const configPath = join22(root, ".story", "config.json");
+    const rawContent = readFileSync9(configPath, "utf-8");
     const raw = JSON.parse(rawContent);
     if (clear) {
       delete raw.recipeOverrides;
@@ -13835,7 +14273,7 @@ async function runCli() {
     registerSessionCommand: registerSessionCommand2,
     registerRepairCommand: registerRepairCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.35";
+  const version2 = "0.1.37";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");