@anthropologies/claudestory 0.1.10 → 0.1.12

package/dist/cli.js

@@ -197,15 +197,9 @@ var init_note = __esm({
     init_types();
     NoteSchema = z4.object({
       id: NoteIdSchema,
-      title: z4.preprocess((v) => v ?? null, z4.string().nullable()),
+      title: z4.string().nullable(),
       content: z4.string().refine((v) => v.trim().length > 0, "Content cannot be empty"),
-      tags: z4.preprocess(
-        (v) => {
-          const raw = Array.isArray(v) ? v : [];
-          return raw.filter((t) => typeof t === "string").map((t) => t.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "")).filter((t) => t.length > 0).filter((t, i, a) => a.indexOf(t) === i);
-        },
-        z4.array(z4.string())
-      ),
+      tags: z4.array(z4.string()),
       status: z4.enum(NOTE_STATUSES),
       createdDate: DateSchema,
       updatedDate: DateSchema
@@ -267,7 +261,8 @@ var init_config = __esm({
       project: z6.string().min(1),
       type: z6.string(),
       language: z6.string(),
-      features: FeaturesSchema
+      features: FeaturesSchema,
+      recipe: z6.string().optional()
     }).passthrough();
   }
 });
@@ -677,6 +672,12 @@ async function writeTicketUnlocked(ticket, root) {
   const json = serializeJSON(parsed);
   await atomicWrite(targetPath, json);
 }
+async function writeTicket(ticket, root) {
+  const wrapDir = resolve2(root, ".story");
+  await withLock(wrapDir, async () => {
+    await writeTicketUnlocked(ticket, root);
+  });
+}
 async function writeIssueUnlocked(issue, root) {
   const parsed = IssueSchema.parse(issue);
   if (!ISSUE_ID_REGEX.test(parsed.id)) {
@@ -691,6 +692,12 @@ async function writeIssueUnlocked(issue, root) {
   const json = serializeJSON(parsed);
   await atomicWrite(targetPath, json);
 }
+async function writeIssue(issue, root) {
+  const wrapDir = resolve2(root, ".story");
+  await withLock(wrapDir, async () => {
+    await writeIssueUnlocked(issue, root);
+  });
+}
 async function writeRoadmapUnlocked(roadmap, root) {
   const parsed = RoadmapSchema.parse(roadmap);
   const wrapDir = resolve2(root, ".story");
@@ -798,6 +805,12 @@ async function writeNoteUnlocked(note, root) {
   const json = serializeJSON(parsed);
   await atomicWrite(targetPath, json);
 }
+async function writeNote(note, root) {
+  const wrapDir = resolve2(root, ".story");
+  await withLock(wrapDir, async () => {
+    await writeNoteUnlocked(note, root);
+  });
+}
 async function deleteNote(id, root) {
   if (!NOTE_ID_REGEX.test(id)) {
     throw new ProjectLoaderError(
@@ -1519,6 +1532,7 @@ __export(output_formatter_exports, {
   formatRecap: () => formatRecap,
   formatRecommendations: () => formatRecommendations,
   formatReference: () => formatReference,
+  formatSelftestResult: () => formatSelftestResult,
   formatSnapshotResult: () => formatSnapshotResult,
   formatStatus: () => formatStatus,
   formatTicket: () => formatTicket,
@@ -2016,6 +2030,16 @@ function formatRecap(recap, state, format) {
           lines.push(`- ${escapeMarkdownInline(name)} \u2014 **new**`);
         }
       }
+      if (changes.handovers && (changes.handovers.added.length > 0 || changes.handovers.removed.length > 0)) {
+        lines.push("");
+        lines.push("## Handovers");
+        for (const h of changes.handovers.added) {
+          lines.push(`- ${h} \u2014 **new**`);
+        }
+        for (const h of changes.handovers.removed) {
+          lines.push(`- ${h} \u2014 removed`);
+        }
+      }
       if (changes.notes && (changes.notes.added.length > 0 || changes.notes.removed.length > 0 || changes.notes.updated.length > 0)) {
         lines.push("");
         lines.push("## Notes");
@@ -2237,7 +2261,35 @@ function formatFullExport(state, format) {
   return lines.join("\n");
 }
 function hasAnyChanges(diff) {
-  return diff.tickets.added.length > 0 || diff.tickets.removed.length > 0 || diff.tickets.statusChanged.length > 0 || diff.tickets.descriptionChanged.length > 0 || diff.issues.added.length > 0 || diff.issues.resolved.length > 0 || diff.issues.statusChanged.length > 0 || diff.issues.impactChanged.length > 0 || diff.blockers.added.length > 0 || diff.blockers.cleared.length > 0 || diff.phases.added.length > 0 || diff.phases.removed.length > 0 || diff.phases.statusChanged.length > 0 || (diff.notes?.added.length ?? 0) > 0 || (diff.notes?.removed.length ?? 0) > 0 || (diff.notes?.updated.length ?? 0) > 0;
+  return diff.tickets.added.length > 0 || diff.tickets.removed.length > 0 || diff.tickets.statusChanged.length > 0 || diff.tickets.descriptionChanged.length > 0 || diff.issues.added.length > 0 || diff.issues.resolved.length > 0 || diff.issues.statusChanged.length > 0 || diff.issues.impactChanged.length > 0 || diff.blockers.added.length > 0 || diff.blockers.cleared.length > 0 || diff.phases.added.length > 0 || diff.phases.removed.length > 0 || diff.phases.statusChanged.length > 0 || (diff.notes?.added.length ?? 0) > 0 || (diff.notes?.removed.length ?? 0) > 0 || (diff.notes?.updated.length ?? 0) > 0 || (diff.handovers?.added.length ?? 0) > 0 || (diff.handovers?.removed.length ?? 0) > 0;
+}
+function formatSelftestResult(result, format) {
+  if (format === "json") {
+    return JSON.stringify(successEnvelope(result), null, 2);
+  }
+  const lines = ["# Self-test Report", ""];
+  const entities = ["ticket", "issue", "note"];
+  for (const entity of entities) {
+    const checks = result.results.filter((r) => r.entity === entity);
+    if (checks.length === 0) continue;
+    lines.push(`## ${entity.charAt(0).toUpperCase() + entity.slice(1)}`);
+    for (const check of checks) {
+      const mark = check.passed ? "[x]" : "[ ]";
+      const suffix = check.passed ? "" : ` \u2014 ${check.detail}`;
+      lines.push(`- ${mark} ${check.step}${suffix}`);
+    }
+    lines.push("");
+  }
+  if (result.cleanupErrors.length > 0) {
+    lines.push("## Cleanup Warnings");
+    lines.push("");
+    for (const err of result.cleanupErrors) {
+      lines.push(`- ${err}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Result: ${result.passed}/${result.total} passed`);
+  return lines.join("\n");
 }
 function truncate(text, maxLen) {
   if (text.length <= maxLen) return text;
@@ -2721,9 +2773,9 @@ async function handleHandoverCreate(content, slugRaw, format, root) {
     const datePrefix = `${date}-`;
     const seqRegex = new RegExp(`^${date}-(\\d{2})-`);
     let maxSeq = 0;
-    const { readdirSync } = await import("fs");
+    const { readdirSync: readdirSync2 } = await import("fs");
     try {
-      for (const f of readdirSync(handoversDir)) {
+      for (const f of readdirSync2(handoversDir)) {
         const m = f.match(seqRegex);
         if (m) {
           const n = parseInt(m[1], 10);
@@ -2814,11 +2866,9 @@ async function handleBlockerClear(name, note, format, root) {
     const updated = {
       ...existing,
       cleared: true,
-      clearedDate: todayISO()
+      clearedDate: todayISO(),
+      ...note !== void 0 && { note }
     };
-    if (note !== void 0) {
-      updated.note = note;
-    }
     const newBlockers = [...state.roadmap.blockers];
     newBlockers[idx] = updated;
     const newRoadmap = { ...state.roadmap, blockers: newBlockers };
@@ -3046,6 +3096,12 @@ async function handleTicketUpdate(id, updates, format, root) {
       `Unknown ticket status "${updates.status}": must be one of ${TICKET_STATUSES.join(", ")}`
     );
   }
+  if (updates.type !== void 0 && !TICKET_TYPES.includes(updates.type)) {
+    throw new CliValidationError(
+      "invalid_input",
+      `Unknown ticket type "${updates.type}": must be one of ${TICKET_TYPES.join(", ")}`
+    );
+  }
   let updatedTicket;
   await withProjectLock(root, { strict: true }, async ({ state }) => {
     const existing = state.ticketByID(id);
@@ -3061,21 +3117,26 @@ async function handleTicketUpdate(id, updates, format, root) {
     if (updates.parentTicket) {
       validateParentTicket(updates.parentTicket, id, state);
     }
-    const ticket = { ...existing };
-    if (updates.title !== void 0) ticket.title = updates.title;
-    if (updates.description !== void 0) ticket.description = updates.description;
-    if (updates.phase !== void 0) ticket.phase = updates.phase;
-    if (updates.order !== void 0) ticket.order = updates.order;
-    if (updates.blockedBy !== void 0) ticket.blockedBy = updates.blockedBy;
-    if (updates.parentTicket !== void 0) ticket.parentTicket = updates.parentTicket === null ? void 0 : updates.parentTicket;
+    const statusChanges = {};
     if (updates.status !== void 0 && updates.status !== existing.status) {
-      ticket.status = updates.status;
+      statusChanges.status = updates.status;
       if (updates.status === "complete" && existing.status !== "complete") {
-        ticket.completedDate = todayISO();
+        statusChanges.completedDate = todayISO();
       } else if (updates.status !== "complete" && existing.status === "complete") {
-        ticket.completedDate = null;
+        statusChanges.completedDate = null;
       }
     }
+    const ticket = {
+      ...existing,
+      ...updates.title !== void 0 && { title: updates.title },
+      ...updates.type !== void 0 && { type: updates.type },
+      ...updates.description !== void 0 && { description: updates.description },
+      ...updates.phase !== void 0 && { phase: updates.phase },
+      ...updates.order !== void 0 && { order: updates.order },
+      ...updates.blockedBy !== void 0 && { blockedBy: updates.blockedBy },
+      ...updates.parentTicket !== void 0 && { parentTicket: updates.parentTicket },
+      ...statusChanges
+    };
     validatePostWriteState(ticket, state, false);
     await writeTicketUnlocked(ticket, root);
     updatedTicket = ticket;
@@ -3191,6 +3252,9 @@ async function handleIssueCreate(args, format, root) {
   }
   let createdIssue;
   await withProjectLock(root, { strict: true }, async ({ state }) => {
+    if (args.phase && !state.roadmap.phases.some((p) => p.id === args.phase)) {
+      throw new CliValidationError("invalid_input", `Phase "${args.phase}" not found in roadmap`);
+    }
     if (args.relatedTickets.length > 0) {
       validateRelatedTickets(args.relatedTickets, state);
     }
@@ -3238,25 +3302,36 @@ async function handleIssueUpdate(id, updates, format, root) {
     if (!existing) {
       throw new CliValidationError("not_found", `Issue ${id} not found`);
     }
+    if (updates.phase !== void 0 && updates.phase !== null) {
+      if (!state.roadmap.phases.some((p) => p.id === updates.phase)) {
+        throw new CliValidationError("invalid_input", `Phase "${updates.phase}" not found in roadmap`);
+      }
+    }
     if (updates.relatedTickets) {
       validateRelatedTickets(updates.relatedTickets, state);
     }
-    const issue = { ...existing };
-    if (updates.title !== void 0) issue.title = updates.title;
-    if (updates.severity !== void 0) issue.severity = updates.severity;
-    if (updates.impact !== void 0) issue.impact = updates.impact;
-    if (updates.resolution !== void 0) issue.resolution = updates.resolution;
-    if (updates.components !== void 0) issue.components = updates.components;
-    if (updates.relatedTickets !== void 0) issue.relatedTickets = updates.relatedTickets;
-    if (updates.location !== void 0) issue.location = updates.location;
+    const statusChanges = {};
     if (updates.status !== void 0 && updates.status !== existing.status) {
-      issue.status = updates.status;
+      statusChanges.status = updates.status;
       if (updates.status === "resolved" && existing.status !== "resolved") {
-        issue.resolvedDate = todayISO();
+        statusChanges.resolvedDate = todayISO();
       } else if (updates.status !== "resolved" && existing.status === "resolved") {
-        issue.resolvedDate = null;
+        statusChanges.resolvedDate = null;
       }
     }
+    const issue = {
+      ...existing,
+      ...updates.title !== void 0 && { title: updates.title },
+      ...updates.severity !== void 0 && { severity: updates.severity },
+      ...updates.impact !== void 0 && { impact: updates.impact },
+      ...updates.resolution !== void 0 && { resolution: updates.resolution },
+      ...updates.components !== void 0 && { components: updates.components },
+      ...updates.relatedTickets !== void 0 && { relatedTickets: updates.relatedTickets },
+      ...updates.location !== void 0 && { location: updates.location },
+      ...updates.order !== void 0 && { order: updates.order },
+      ...updates.phase !== void 0 && { phase: updates.phase },
+      ...statusChanges
+    };
     validatePostWriteIssueState(issue, state, false);
     await writeIssueUnlocked(issue, root);
     updatedIssue = issue;
@@ -3289,6 +3364,14 @@ var init_issue2 = __esm({
 });
 
 // src/core/snapshot.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  SnapshotV1Schema: () => SnapshotV1Schema,
+  buildRecap: () => buildRecap,
+  diffStates: () => diffStates,
+  loadLatestSnapshot: () => loadLatestSnapshot,
+  saveSnapshot: () => saveSnapshot
+});
 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";
@@ -3309,6 +3392,7 @@ async function saveSnapshot(root, loadResult) {
     tickets: [...state.tickets],
     issues: [...state.issues],
     notes: [...state.notes],
+    handoverFilenames: [...state.handoverFilenames],
     ...warnings.length > 0 ? {
       warnings: warnings.map((w) => ({
         type: w.type,
@@ -3461,12 +3545,23 @@ function diffStates(snapshotState, currentState) {
       notesRemoved.push({ id, title: snap.title });
     }
   }
+  const snapHandovers = new Set(snapshotState.handoverFilenames);
+  const curHandovers = new Set(currentState.handoverFilenames);
+  const handoversAdded = [];
+  const handoversRemoved = [];
+  for (const h of curHandovers) {
+    if (!snapHandovers.has(h)) handoversAdded.push(h);
+  }
+  for (const h of snapHandovers) {
+    if (!curHandovers.has(h)) handoversRemoved.push(h);
+  }
   return {
     tickets: { added: ticketsAdded, removed: ticketsRemoved, statusChanged: ticketsStatusChanged, descriptionChanged: ticketsDescriptionChanged },
     issues: { added: issuesAdded, resolved: issuesResolved, statusChanged: issuesStatusChanged, impactChanged: issuesImpactChanged },
     blockers: { added: blockersAdded, cleared: blockersCleared },
     phases: { added: phasesAdded, removed: phasesRemoved, statusChanged: phasesStatusChanged },
-    notes: { added: notesAdded, removed: notesRemoved, updated: notesUpdated }
+    notes: { added: notesAdded, removed: notesRemoved, updated: notesUpdated },
+    handovers: { added: handoversAdded, removed: handoversRemoved }
   };
 }
 function buildRecap(currentState, snapshotInfo) {
@@ -3494,7 +3589,7 @@ function buildRecap(currentState, snapshotInfo) {
     notes: snapshot.notes ?? [],
     roadmap: snapshot.roadmap,
     config: snapshot.config,
-    handoverFilenames: []
+    handoverFilenames: snapshot.handoverFilenames ?? []
   });
   const changes = diffStates(snapshotState, currentState);
   const recentlyClearedBlockers = changes.blockers.cleared;
@@ -3566,6 +3661,7 @@ var init_snapshot = __esm({
       tickets: z7.array(TicketSchema),
       issues: z7.array(IssueSchema),
       notes: z7.array(NoteSchema).optional().default([]),
+      handoverFilenames: z7.array(z7.string()).optional().default([]),
       warnings: z7.array(LoadWarningSchema).optional()
     });
     MAX_SNAPSHOTS = 20;
@@ -3666,23 +3762,22 @@ async function handleNoteUpdate(id, updates, format, root) {
     if (!existing) {
       throw new CliValidationError("not_found", `Note ${id} not found`);
     }
-    const note = { ...existing };
-    if (updates.content !== void 0) {
-      note.content = updates.content;
-    }
-    if (updates.title !== void 0) {
-      const trimmed = updates.title?.trim();
-      note.title = !trimmed ? null : updates.title;
-    }
+    const tagsUpdate = {};
     if (updates.clearTags) {
-      note.tags = [];
+      tagsUpdate.tags = [];
     } else if (updates.tags !== void 0) {
-      note.tags = normalizeTags(updates.tags);
-    }
-    if (updates.status !== void 0) {
-      note.status = updates.status;
+      tagsUpdate.tags = normalizeTags(updates.tags);
     }
-    note.updatedDate = todayISO();
+    const note = {
+      ...existing,
+      ...updates.content !== void 0 && { content: updates.content },
+      ...updates.title !== void 0 && {
+        title: !updates.title?.trim() ? null : updates.title
+      },
+      ...tagsUpdate,
+      ...updates.status !== void 0 && { status: updates.status },
+      updatedDate: todayISO()
+    };
     await writeNoteUnlocked(note, root);
     updatedNote = note;
   });
@@ -4005,116 +4100,1864 @@ var init_export = __esm({
   }
 });
 
-// src/cli/commands/phase.ts
-import { join as join6, 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`);
+// src/cli/commands/selftest.ts
+async function handleSelftest(root, format, failAfter) {
+  const results = [];
+  const createdIds = [];
+  const cleanupErrors = [];
+  function record(entity, step, passed2, detail) {
+    results.push({ entity, step, passed: passed2, detail });
+    if (failAfter !== void 0 && results.filter((r) => r.passed).length >= failAfter) {
+      throw new Error(`failAfter(${failAfter}): induced failure for testing`);
+    }
   }
-  if (!PHASE_ID_REGEX.test(id)) {
-    throw new CliValidationError("invalid_input", `Phase ID "${id}" must be lowercase alphanumeric with hyphens (e.g. "my-phase")`);
+  try {
+    let ticketId;
+    try {
+      const { state } = await loadProject(root);
+      ticketId = nextTicketID(state.tickets);
+      const today = todayISO();
+      const ticket = {
+        id: ticketId,
+        title: "selftest ticket",
+        type: "chore",
+        status: "open",
+        phase: null,
+        order: 0,
+        description: "Integration smoke test \u2014 will be deleted.",
+        createdDate: today,
+        completedDate: null,
+        blockedBy: [],
+        parentTicket: null
+      };
+      await writeTicket(ticket, root);
+      createdIds.push({ type: "ticket", id: ticketId });
+      record("ticket", "create", true, `Created ${ticketId}`);
+    } catch (err) {
+      record("ticket", "create", false, errMsg(err));
+    }
+    if (ticketId) {
+      try {
+        const { state } = await loadProject(root);
+        const found = state.ticketByID(ticketId);
+        if (!found) throw new Error(`${ticketId} not found after create`);
+        record("ticket", "get", true, `Found ${ticketId}`);
+      } catch (err) {
+        record("ticket", "get", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const existing = state.ticketByID(ticketId);
+        if (!existing) throw new Error(`${ticketId} not found for update`);
+        const updated = { ...existing, status: "inprogress" };
+        await writeTicket(updated, root);
+        record("ticket", "update", true, `Updated ${ticketId} status \u2192 inprogress`);
+      } catch (err) {
+        record("ticket", "update", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.ticketByID(ticketId);
+        if (!found) throw new Error(`${ticketId} not found for verify`);
+        if (found.status !== "inprogress") throw new Error(`Expected inprogress, got ${found.status}`);
+        record("ticket", "verify update", true, `Verified ${ticketId} status = inprogress`);
+      } catch (err) {
+        record("ticket", "verify update", false, errMsg(err));
+      }
+      try {
+        await deleteTicket(ticketId, root, { force: true });
+        createdIds.splice(createdIds.findIndex((c) => c.id === ticketId), 1);
+        record("ticket", "delete", true, `Deleted ${ticketId}`);
+      } catch (err) {
+        record("ticket", "delete", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.ticketByID(ticketId);
+        if (found) throw new Error(`${ticketId} still exists after delete`);
+        record("ticket", "verify delete", true, `Confirmed ${ticketId} absent`);
+      } catch (err) {
+        record("ticket", "verify delete", false, errMsg(err));
+      }
+    }
+    let issueId;
+    try {
+      const { state } = await loadProject(root);
+      issueId = nextIssueID(state.issues);
+      const today = todayISO();
+      const issue = {
+        id: issueId,
+        title: "selftest issue",
+        status: "open",
+        severity: "low",
+        components: [],
+        impact: "Integration smoke test \u2014 will be deleted.",
+        resolution: null,
+        location: [],
+        discoveredDate: today,
+        resolvedDate: null,
+        relatedTickets: [],
+        order: 0,
+        phase: null
+      };
+      await writeIssue(issue, root);
+      createdIds.push({ type: "issue", id: issueId });
+      record("issue", "create", true, `Created ${issueId}`);
+    } catch (err) {
+      record("issue", "create", false, errMsg(err));
+    }
+    if (issueId) {
+      try {
+        const { state } = await loadProject(root);
+        const found = state.issueByID(issueId);
+        if (!found) throw new Error(`${issueId} not found after create`);
+        record("issue", "get", true, `Found ${issueId}`);
+      } catch (err) {
+        record("issue", "get", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const existing = state.issueByID(issueId);
+        if (!existing) throw new Error(`${issueId} not found for update`);
+        const updated = { ...existing, status: "inprogress" };
+        await writeIssue(updated, root);
+        record("issue", "update", true, `Updated ${issueId} status \u2192 inprogress`);
+      } catch (err) {
+        record("issue", "update", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.issueByID(issueId);
+        if (!found) throw new Error(`${issueId} not found for verify`);
+        if (found.status !== "inprogress") throw new Error(`Expected inprogress, got ${found.status}`);
+        record("issue", "verify update", true, `Verified ${issueId} status = inprogress`);
+      } catch (err) {
+        record("issue", "verify update", false, errMsg(err));
+      }
+      try {
+        await deleteIssue(issueId, root);
+        createdIds.splice(createdIds.findIndex((c) => c.id === issueId), 1);
+        record("issue", "delete", true, `Deleted ${issueId}`);
+      } catch (err) {
+        record("issue", "delete", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.issueByID(issueId);
+        if (found) throw new Error(`${issueId} still exists after delete`);
+        record("issue", "verify delete", true, `Confirmed ${issueId} absent`);
+      } catch (err) {
+        record("issue", "verify delete", false, errMsg(err));
+      }
+    }
+    let noteId;
+    try {
+      const { state } = await loadProject(root);
+      noteId = nextNoteID(state.notes);
+      const today = todayISO();
+      const note = {
+        id: noteId,
+        title: "selftest note",
+        content: "Integration smoke test \u2014 will be deleted.",
+        tags: [],
+        status: "active",
+        createdDate: today,
+        updatedDate: today
+      };
+      await writeNote(note, root);
+      createdIds.push({ type: "note", id: noteId });
+      record("note", "create", true, `Created ${noteId}`);
+    } catch (err) {
+      record("note", "create", false, errMsg(err));
+    }
+    if (noteId) {
+      try {
+        const { state } = await loadProject(root);
+        const found = state.noteByID(noteId);
+        if (!found) throw new Error(`${noteId} not found after create`);
+        record("note", "get", true, `Found ${noteId}`);
+      } catch (err) {
+        record("note", "get", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const existing = state.noteByID(noteId);
+        if (!existing) throw new Error(`${noteId} not found for update`);
+        const updated = { ...existing, status: "archived", updatedDate: todayISO() };
+        await writeNote(updated, root);
+        record("note", "update", true, `Updated ${noteId} status \u2192 archived`);
+      } catch (err) {
+        record("note", "update", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.noteByID(noteId);
+        if (!found) throw new Error(`${noteId} not found for verify`);
+        if (found.status !== "archived") throw new Error(`Expected archived, got ${found.status}`);
+        record("note", "verify update", true, `Verified ${noteId} status = archived`);
+      } catch (err) {
+        record("note", "verify update", false, errMsg(err));
+      }
+      try {
+        await deleteNote(noteId, root);
+        createdIds.splice(createdIds.findIndex((c) => c.id === noteId), 1);
+        record("note", "delete", true, `Deleted ${noteId}`);
+      } catch (err) {
+        record("note", "delete", false, errMsg(err));
+      }
+      try {
+        const { state } = await loadProject(root);
+        const found = state.noteByID(noteId);
+        if (found) throw new Error(`${noteId} still exists after delete`);
+        record("note", "verify delete", true, `Confirmed ${noteId} absent`);
+      } catch (err) {
+        record("note", "verify delete", false, errMsg(err));
+      }
+    }
+  } finally {
+    for (const { type, id } of createdIds.reverse()) {
+      try {
+        if (type === "ticket") await deleteTicket(id, root, { force: true });
+        else if (type === "issue") await deleteIssue(id, root);
+        else await deleteNote(id, root);
+      } catch (err) {
+        cleanupErrors.push(`Failed to delete ${type} ${id}: ${errMsg(err)}`);
+      }
+    }
   }
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  const result = {
+    passed,
+    failed,
+    total: results.length,
+    results,
+    cleanupErrors
+  };
+  return { output: formatSelftestResult(result, format) };
 }
-function handlePhaseList(ctx) {
-  return { output: formatPhaseList(ctx.state, ctx.format) };
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-function handlePhaseCurrent(ctx) {
-  const phase = currentPhase(ctx.state);
-  if (phase) {
-    if (ctx.format === "json") {
-      return { output: JSON.stringify(successEnvelope(phase), null, 2) };
-    }
-    const summary = phase.summary ?? phase.description;
-    return { output: `${phase.name} (${phase.id}) \u2014 ${summary}` };
+var init_selftest = __esm({
+  "src/cli/commands/selftest.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_loader();
+    init_id_allocation();
+    init_output_formatter();
+    init_helpers();
   }
-  const hasLeavesInAnyPhase = ctx.state.roadmap.phases.some(
-    (p) => ctx.state.phaseTickets(p.id).length > 0
-  );
-  if (!hasLeavesInAnyPhase) {
-    if (ctx.format === "json") {
-      return {
-        output: JSON.stringify(successEnvelope({ current: null, reason: "no_phases" }), null, 2),
-        exitCode: ExitCode.USER_ERROR
-      };
+});
+
+// src/autonomous/session-types.ts
+import { realpathSync } from "fs";
+import { z as z8 } from "zod";
+function deriveClaudeStatus(state, waitingForRetry) {
+  if (waitingForRetry) return "waiting";
+  if (!state) return "idle";
+  if (WORKING_STATES.has(state)) return "working";
+  if (IDLE_STATES.has(state)) return "idle";
+  return "unknown";
+}
+function deriveWorkspaceId(projectRoot) {
+  return realpathSync(projectRoot);
+}
+var WORKING_STATES, IDLE_STATES, CURRENT_STATUS_SCHEMA_VERSION, WORKFLOW_STATES, WorkflowStateSchema, CURRENT_SESSION_SCHEMA_VERSION, SessionStateSchema;
+var init_session_types = __esm({
+  "src/autonomous/session-types.ts"() {
+    "use strict";
+    init_esm_shims();
+    WORKING_STATES = /* @__PURE__ */ new Set([
+      "PLAN",
+      "PLAN_REVIEW",
+      "IMPLEMENT",
+      "CODE_REVIEW",
+      "FINALIZE",
+      "COMPACT"
+    ]);
+    IDLE_STATES = /* @__PURE__ */ new Set([
+      "INIT",
+      "LOAD_CONTEXT",
+      "PICK_TICKET",
+      "HANDOVER",
+      "COMPLETE",
+      "SESSION_END"
+    ]);
+    CURRENT_STATUS_SCHEMA_VERSION = 1;
+    WORKFLOW_STATES = [
+      "INIT",
+      "LOAD_CONTEXT",
+      "PICK_TICKET",
+      "PLAN",
+      "PLAN_REVIEW",
+      "IMPLEMENT",
+      "CODE_REVIEW",
+      "FINALIZE",
+      "COMPACT",
+      "HANDOVER",
+      "COMPLETE",
+      "SESSION_END"
+    ];
+    WorkflowStateSchema = z8.enum(WORKFLOW_STATES);
+    CURRENT_SESSION_SCHEMA_VERSION = 1;
+    SessionStateSchema = z8.object({
+      schemaVersion: z8.literal(CURRENT_SESSION_SCHEMA_VERSION),
+      sessionId: z8.string().uuid(),
+      recipe: z8.string(),
+      state: z8.string(),
+      previousState: z8.string().optional(),
+      revision: z8.number().int().min(0),
+      status: z8.enum(["active", "completed", "superseded"]).default("active"),
+      // Ticket in progress
+      ticket: z8.object({
+        id: z8.string(),
+        title: z8.string(),
+        risk: z8.string().optional(),
+        realizedRisk: z8.string().optional(),
+        claimed: z8.boolean().default(false)
+      }).optional(),
+      // Review tracking
+      reviews: z8.object({
+        plan: z8.array(z8.object({
+          round: z8.number(),
+          reviewer: z8.string(),
+          verdict: z8.string(),
+          findingCount: z8.number(),
+          criticalCount: z8.number(),
+          majorCount: z8.number(),
+          suggestionCount: z8.number(),
+          codexSessionId: z8.string().optional(),
+          timestamp: z8.string()
+        })).default([]),
+        code: z8.array(z8.object({
+          round: z8.number(),
+          reviewer: z8.string(),
+          verdict: z8.string(),
+          findingCount: z8.number(),
+          criticalCount: z8.number(),
+          majorCount: z8.number(),
+          suggestionCount: z8.number(),
+          codexSessionId: z8.string().optional(),
+          timestamp: z8.string()
+        })).default([])
+      }).default({ plan: [], code: [] }),
+      // Completed tickets this session
+      completedTickets: z8.array(z8.object({
+        id: z8.string(),
+        title: z8.string().optional(),
+        commitHash: z8.string().optional(),
+        risk: z8.string().optional()
+      })).default([]),
+      // FINALIZE checkpoint
+      finalizeCheckpoint: z8.enum(["staged", "precommit_passed", "committed"]).nullable().default(null),
+      // Git state
+      git: z8.object({
+        branch: z8.string().nullable().default(null),
+        initHead: z8.string().optional(),
+        mergeBase: z8.string().nullable().default(null),
+        expectedHead: z8.string().optional(),
+        baseline: z8.object({
+          porcelain: z8.array(z8.string()).default([]),
+          dirtyTrackedFiles: z8.record(z8.object({ blobHash: z8.string() })).default({}),
+          untrackedPaths: z8.array(z8.string()).default([])
+        }).optional()
+      }).default({ branch: null, mergeBase: null }),
+      // Lease
+      lease: z8.object({
+        workspaceId: z8.string().optional(),
+        lastHeartbeat: z8.string(),
+        expiresAt: z8.string()
+      }),
+      // Context pressure
+      contextPressure: z8.object({
+        level: z8.string().default("low"),
+        guideCallCount: z8.number().default(0),
+        ticketsCompleted: z8.number().default(0),
+        compactionCount: z8.number().default(0),
+        eventsLogBytes: z8.number().default(0)
+      }).default({ level: "low", guideCallCount: 0, ticketsCompleted: 0, compactionCount: 0, eventsLogBytes: 0 }),
+      // Pending project mutation (for crash recovery)
+      pendingProjectMutation: z8.any().nullable().default(null),
+      // COMPACT resume
+      resumeFromRevision: z8.number().nullable().default(null),
+      preCompactState: z8.string().nullable().default(null),
+      // Session metadata
+      waitingForRetry: z8.boolean().default(false),
+      lastGuideCall: z8.string().optional(),
+      startedAt: z8.string(),
+      guideCallCount: z8.number().default(0),
+      // Supersession tracking
+      supersededBy: z8.string().optional(),
+      supersededSession: z8.string().optional(),
+      stealReason: z8.string().optional(),
+      // Recipe overrides
+      config: z8.object({
+        maxTicketsPerSession: z8.number().default(3),
+        compactThreshold: z8.string().default("high"),
+        reviewBackends: z8.array(z8.string()).default(["codex", "agent"])
+      }).default({ maxTicketsPerSession: 3, compactThreshold: "high", reviewBackends: ["codex", "agent"] })
+    }).passthrough();
+  }
+});
+
+// src/autonomous/session.ts
+import { randomUUID } from "crypto";
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  unlinkSync,
+  existsSync as existsSync6,
+  rmSync
+} from "fs";
+import { join as join6 } from "path";
+import lockfile2 from "proper-lockfile";
+function sessionsRoot(root) {
+  return join6(root, ".story", SESSIONS_DIR);
+}
+function sessionDir(root, sessionId) {
+  return join6(sessionsRoot(root), sessionId);
+}
+function statePath(dir) {
+  return join6(dir, "state.json");
+}
+function eventsPath(dir) {
+  return join6(dir, "events.log");
+}
+function createSession(root, recipe, workspaceId) {
+  const id = randomUUID();
+  const dir = sessionDir(root, id);
+  mkdirSync(dir, { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    schemaVersion: CURRENT_SESSION_SCHEMA_VERSION,
+    sessionId: id,
+    recipe,
+    state: "INIT",
+    revision: 0,
+    status: "active",
+    reviews: { plan: [], code: [] },
+    completedTickets: [],
+    finalizeCheckpoint: null,
+    git: { branch: null, mergeBase: null },
+    lease: {
+      workspaceId,
+      lastHeartbeat: now,
+      expiresAt: new Date(Date.now() + LEASE_DURATION_MS).toISOString()
+    },
+    contextPressure: {
+      level: "low",
+      guideCallCount: 0,
+      ticketsCompleted: 0,
+      compactionCount: 0,
+      eventsLogBytes: 0
+    },
+    pendingProjectMutation: null,
+    resumeFromRevision: null,
+    preCompactState: null,
+    waitingForRetry: false,
+    lastGuideCall: now,
+    startedAt: now,
+    guideCallCount: 0,
+    config: {
+      maxTicketsPerSession: 3,
+      compactThreshold: "high",
+      reviewBackends: ["codex", "agent"]
     }
-    return {
-      output: "No phases with tickets defined.",
-      exitCode: ExitCode.USER_ERROR
-    };
+  };
+  writeSessionSync(dir, state);
+  return state;
+}
+function readSession(dir) {
+  const path2 = statePath(dir);
+  let raw;
+  try {
+    raw = readFileSync(path2, "utf-8");
+  } catch {
+    return null;
   }
-  if (ctx.format === "json") {
-    return {
-      output: JSON.stringify(successEnvelope({ current: null, reason: "all_complete" }), null, 2)
-    };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
   }
-  return { output: "All phases complete." };
+  const result = SessionStateSchema.safeParse(parsed);
+  if (!result.success) return null;
+  return result.data;
 }
-function handlePhaseTickets(phaseId, ctx) {
-  const phaseExists = ctx.state.roadmap.phases.some((p) => p.id === phaseId);
-  if (!phaseExists) {
-    return {
-      output: formatError("not_found", `Phase "${phaseId}" not found`, ctx.format),
-      exitCode: ExitCode.USER_ERROR,
-      errorCode: "not_found"
-    };
+function writeSessionSync(dir, state) {
+  const path2 = statePath(dir);
+  const updated = { ...state, revision: state.revision + 1 };
+  const content = JSON.stringify(updated, null, 2) + "\n";
+  const tmp = `${path2}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, content, "utf-8");
+    renameSync(tmp, path2);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
   }
-  return { output: formatPhaseTickets(phaseId, ctx.state, ctx.format) };
+  return updated;
 }
-async function handlePhaseCreate(args, format, root) {
-  validatePhaseId(args.id);
-  if (args.atStart && args.after) {
-    throw new CliValidationError("invalid_input", "Cannot use both --after and --at-start");
-  }
-  if (!args.atStart && !args.after) {
-    throw new CliValidationError("invalid_input", "Must specify either --after <phase-id> or --at-start");
+function appendEvent(dir, event) {
+  try {
+    const path2 = eventsPath(dir);
+    const line = JSON.stringify(event) + "\n";
+    writeFileSync(path2, line, { flag: "a", encoding: "utf-8" });
+  } catch {
   }
-  let createdPhase;
-  await withProjectLock(root, { strict: true }, async ({ state }) => {
-    if (state.roadmap.phases.some((p) => p.id === args.id)) {
-      throw new CliValidationError("conflict", `Phase "${args.id}" already exists`);
-    }
-    const phase = {
-      id: args.id,
-      label: args.label,
-      name: args.name,
-      description: args.description
-    };
-    if (args.summary !== void 0) {
-      phase.summary = args.summary;
-    }
-    const newPhases = [...state.roadmap.phases];
-    if (args.atStart) {
-      newPhases.unshift(phase);
-    } else {
-      const afterIdx = newPhases.findIndex((p) => p.id === args.after);
-      if (afterIdx < 0) {
-        throw new CliValidationError("not_found", `Phase "${args.after}" not found`);
-      }
-      newPhases.splice(afterIdx + 1, 0, phase);
-    }
-    const newRoadmap = { ...state.roadmap, phases: newPhases };
-    await writeRoadmapUnlocked(newRoadmap, root);
-    createdPhase = phase;
-  });
-  if (!createdPhase) throw new Error("Phase not created");
-  if (format === "json") {
-    return { output: JSON.stringify(successEnvelope(createdPhase), null, 2) };
+}
+function deleteSession(root, sessionId) {
+  const dir = sessionDir(root, sessionId);
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
   }
-  return { output: `Created phase ${createdPhase.id}: ${createdPhase.name}` };
 }
-async function handlePhaseRename(id, updates, format, root) {
-  let updatedPhase;
-  await withProjectLock(root, { strict: true }, async ({ state }) => {
-    const idx = state.roadmap.phases.findIndex((p) => p.id === id);
-    if (idx < 0) {
-      throw new CliValidationError("not_found", `Phase "${id}" not found`);
+function refreshLease(state) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newCallCount = state.guideCallCount + 1;
+  return {
+    ...state,
+    lease: {
+      ...state.lease,
+      lastHeartbeat: now,
+      expiresAt: new Date(Date.now() + LEASE_DURATION_MS).toISOString()
+    },
+    lastGuideCall: now,
+    guideCallCount: newCallCount,
+    contextPressure: {
+      ...state.contextPressure,
+      guideCallCount: newCallCount,
+      ticketsCompleted: state.completedTickets?.length ?? 0
     }
-    const existing = state.roadmap.phases[idx];
-    const phase = { ...existing };
-    if (updates.name !== void 0) phase.name = updates.name;
-    if (updates.label !== void 0) phase.label = updates.label;
-    if (updates.description !== void 0) phase.description = updates.description;
-    if (updates.summary !== void 0) phase.summary = updates.summary;
+  };
+}
+function isLeaseExpired(state) {
+  if (!state.lease?.expiresAt) return true;
+  const expires = new Date(state.lease.expiresAt).getTime();
+  return Number.isNaN(expires) || expires <= Date.now();
+}
+function findActiveSessionFull(root) {
+  const sessDir = sessionsRoot(root);
+  let entries;
+  try {
+    entries = readdirSync(sessDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let workspaceId;
+  try {
+    workspaceId = deriveWorkspaceId(root);
+  } catch {
+    return null;
+  }
+  let best = null;
+  let bestGuideCall = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = join6(sessDir, entry.name);
+    const session = readSession(dir);
+    if (!session) continue;
+    if (session.status !== "active") continue;
+    if (session.lease?.workspaceId && session.lease.workspaceId !== workspaceId) continue;
+    if (isLeaseExpired(session)) continue;
+    const guideCall = session.lastGuideCall ? new Date(session.lastGuideCall).getTime() : 0;
+    const guideCallValid = Number.isNaN(guideCall) ? 0 : guideCall;
+    if (!best || guideCallValid > bestGuideCall || guideCallValid === bestGuideCall && session.sessionId > best.state.sessionId) {
+      best = { state: session, dir };
+      bestGuideCall = guideCallValid;
+    }
+  }
+  return best;
+}
+function findActiveSessionMinimal(root) {
+  const result = findActiveSessionFull(root);
+  return result?.state ?? null;
+}
+function findStaleSessions(root) {
+  const sessDir = sessionsRoot(root);
+  let entries;
+  try {
+    entries = readdirSync(sessDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  let workspaceId;
+  try {
+    workspaceId = deriveWorkspaceId(root);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = join6(sessDir, entry.name);
+    const session = readSession(dir);
+    if (!session) continue;
+    if (session.status !== "active") continue;
+    if (session.lease?.workspaceId && session.lease.workspaceId !== workspaceId) continue;
+    if (isLeaseExpired(session)) {
+      results.push({ state: session, dir });
+    }
+  }
+  return results;
+}
+function findSessionById(root, sessionId) {
+  const dir = sessionDir(root, sessionId);
+  if (!existsSync6(dir)) return null;
+  const state = readSession(dir);
+  if (!state) return null;
+  return { state, dir };
+}
+async function withSessionLock(root, fn) {
+  const sessDir = sessionsRoot(root);
+  mkdirSync(sessDir, { recursive: true });
+  let release;
+  try {
+    release = await lockfile2.lock(sessDir, {
+      retries: { retries: 3, minTimeout: 100, maxTimeout: 1e3 },
+      stale: 3e4,
+      lockfilePath: join6(sessDir, ".lock")
+    });
+    return await fn();
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {
+      }
+    }
+  }
+}
+var LEASE_DURATION_MS, SESSIONS_DIR;
+var init_session = __esm({
+  "src/autonomous/session.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_session_types();
+    LEASE_DURATION_MS = 45 * 60 * 1e3;
+    SESSIONS_DIR = "sessions";
+  }
+});
+
+// src/autonomous/state-machine.ts
+var init_state_machine = __esm({
+  "src/autonomous/state-machine.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/autonomous/context-pressure.ts
+function evaluatePressure(state) {
+  const calls = state.contextPressure?.guideCallCount ?? state.guideCallCount ?? 0;
+  const tickets = state.contextPressure?.ticketsCompleted ?? state.completedTickets?.length ?? 0;
+  const eventsBytes = state.contextPressure?.eventsLogBytes ?? 0;
+  if (calls > 45 || tickets >= 3 || eventsBytes > 5e5) return "critical";
+  if (calls >= 30 || tickets >= 2 || eventsBytes > 2e5) return "high";
+  if (calls >= 15 || tickets >= 1 || eventsBytes > 5e4) return "medium";
+  return "low";
+}
+var init_context_pressure = __esm({
+  "src/autonomous/context-pressure.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/autonomous/review-depth.ts
+function assessRisk(diffStats, changedFiles) {
+  let level = "low";
+  if (diffStats) {
+    const total = diffStats.totalLines;
+    if (total > 200) level = "high";
+    else if (total >= 50) level = "medium";
+  }
+  if (changedFiles && level !== "high") {
+    const hasSensitive = changedFiles.some(
+      (f) => SENSITIVE_PATTERNS.some((p) => p.test(f))
+    );
+    if (hasSensitive) {
+      level = level === "low" ? "medium" : "high";
+    }
+  }
+  return level;
+}
+function requiredRounds(risk) {
+  switch (risk) {
+    case "low":
+      return 1;
+    case "medium":
+      return 2;
+    case "high":
+      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];
+  const lastReviewer = previousRounds[previousRounds.length - 1].reviewer;
+  const lastIndex = backends.indexOf(lastReviewer);
+  if (lastIndex === -1) return backends[0];
+  return backends[(lastIndex + 1) % backends.length];
+}
+var SENSITIVE_PATTERNS;
+var init_review_depth = __esm({
+  "src/autonomous/review-depth.ts"() {
+    "use strict";
+    init_esm_shims();
+    SENSITIVE_PATTERNS = [
+      /\bauth\b/i,
+      /\bsecurity\b/i,
+      /\bmigration/i,
+      /\bconfig\b/i,
+      /\bmiddleware\b/i,
+      /\.env/i
+    ];
+  }
+});
+
+// src/autonomous/git-inspector.ts
+import { execFile } from "child_process";
+async function git(cwd, args, parse) {
+  return new Promise((resolve9) => {
+    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";
+        resolve9({ ok: false, reason: "git_error", message });
+        return;
+      }
+      try {
+        resolve9({ ok: true, data: parse(stdout) });
+      } catch (parseErr) {
+        resolve9({ 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)
+  );
+}
+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;
+var init_git_inspector = __esm({
+  "src/autonomous/git-inspector.ts"() {
+    "use strict";
+    init_esm_shims();
+    GIT_TIMEOUT = 1e4;
+  }
+});
+
+// src/autonomous/guide.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+async function handleAutonomousGuide(root, args) {
+  const wsId = deriveWorkspaceId(root);
+  const prev = workspaceLocks.get(wsId) ?? Promise.resolve();
+  const current = prev.then(async () => {
+    return withSessionLock(root, () => handleGuideInner(root, args));
+  });
+  workspaceLocks.set(wsId, current.then(() => {
+  }, () => {
+  }));
+  try {
+    return await current;
+  } catch (err) {
+    return guideError(err);
+  } finally {
+    const stored = workspaceLocks.get(wsId);
+    if (stored) {
+      stored.then(() => {
+        if (workspaceLocks.get(wsId) === stored) {
+          workspaceLocks.delete(wsId);
+        }
+      }, () => {
+        if (workspaceLocks.get(wsId) === stored) {
+          workspaceLocks.delete(wsId);
+        }
+      });
+    }
+  }
+}
+async function handleGuideInner(root, args) {
+  switch (args.action) {
+    case "start":
+      return handleStart(root, args);
+    case "report":
+      return handleReport(root, args);
+    case "resume":
+      return handleResume(root, args);
+    case "pre_compact":
+      return handlePreCompact(root, args);
+    case "cancel":
+      return handleCancel(root, args);
+    default:
+      return guideError(new Error(`Unknown action: ${args.action}`));
+  }
+}
+async function handleStart(root, args) {
+  const existing = findActiveSessionFull(root);
+  if (existing && !isLeaseExpired(existing.state)) {
+    return guideError(new Error(
+      `Active session ${existing.state.sessionId} already exists for this workspace. Use action: "resume" to continue or "cancel" to end it.`
+    ));
+  }
+  const staleSessions = findStaleSessions(root);
+  for (const stale of staleSessions) {
+    writeSessionSync(stale.dir, { ...stale.state, status: "superseded" });
+  }
+  const wsId = deriveWorkspaceId(root);
+  const recipe = "coding";
+  const session = createSession(root, recipe, wsId);
+  const dir = sessionDir(root, session.sessionId);
+  try {
+    const headResult = await gitHead(root);
+    if (!headResult.ok) {
+      deleteSession(root, session.sessionId);
+      return guideError(new Error("This directory is not a git repository or git is not available. Autonomous mode requires git."));
+    }
+    const stagedResult = await gitDiffCachedNames(root);
+    if (stagedResult.ok && stagedResult.data.length > 0) {
+      deleteSession(root, session.sessionId);
+      return guideError(new Error(
+        `Cannot start: ${stagedResult.data.length} staged file(s). Unstage with \`git restore --staged .\` or commit them first, then call start again.
+
+Staged: ${stagedResult.data.join(", ")}`
+      ));
+    }
+    const statusResult = await gitStatus(root);
+    let mergeBaseResult = await gitMergeBase(root, "main");
+    if (!mergeBaseResult.ok) mergeBaseResult = await gitMergeBase(root, "master");
+    const porcelainLines = statusResult.ok ? statusResult.data : [];
+    const dirtyTracked = {};
+    const untrackedPaths = [];
+    for (const line of porcelainLines) {
+      if (line.startsWith("??")) {
+        untrackedPaths.push(line.slice(3).trim());
+      } else if (line.length > 3) {
+        const filePath = line.slice(3).trim();
+        const hashResult = await gitBlobHash(root, filePath);
+        dirtyTracked[filePath] = { blobHash: hashResult.ok ? hashResult.data : "" };
+      }
+    }
+    if (Object.keys(dirtyTracked).length > 0) {
+      deleteSession(root, session.sessionId);
+      const dirtyFiles = Object.keys(dirtyTracked).join(", ");
+      return guideError(new Error(
+        `Cannot start: ${Object.keys(dirtyTracked).length} dirty tracked file(s): ${dirtyFiles}. Create a feature branch or stash changes first, then call start again.`
+      ));
+    }
+    let updated = {
+      ...session,
+      state: "PICK_TICKET",
+      previousState: "INIT",
+      git: {
+        branch: headResult.data.branch,
+        initHead: headResult.data.hash,
+        mergeBase: mergeBaseResult.ok ? mergeBaseResult.data : null,
+        expectedHead: headResult.data.hash,
+        baseline: {
+          porcelain: porcelainLines,
+          dirtyTrackedFiles: dirtyTracked,
+          untrackedPaths
+        }
+      }
+    };
+    const { state: projectState, warnings } = await loadProject(root);
+    const handoversDir = join7(root, ".story", "handovers");
+    const ctx = { state: projectState, warnings, root, handoversDir, format: "md" };
+    let handoverText = "";
+    try {
+      const handoverResult = await handleHandoverLatest(ctx, 3);
+      handoverText = handoverResult.output;
+    } catch {
+    }
+    let recapText = "";
+    try {
+      const snapshotInfo = await loadLatestSnapshot(root);
+      const recap = buildRecap(projectState, snapshotInfo);
+      if (recap.changes) {
+        recapText = "Changes since last snapshot available.";
+      }
+    } catch {
+    }
+    const rulesText = readFileSafe(join7(root, "RULES.md"));
+    const strategiesText = readFileSafe(join7(root, "WORK_STRATEGIES.md"));
+    const digestParts = [
+      handoverText ? `## Recent Handovers
+
+${handoverText}` : "",
+      recapText ? `## Recap
+
+${recapText}` : "",
+      rulesText ? `## Development Rules
+
+${rulesText}` : "",
+      strategiesText ? `## Work Strategies
+
+${strategiesText}` : ""
+    ].filter(Boolean);
+    const digest = digestParts.join("\n\n---\n\n");
+    try {
+      writeFileSync2(join7(dir, "context-digest.md"), digest, "utf-8");
+    } catch {
+    }
+    const nextResult = nextTickets(projectState, 5);
+    let candidatesText = "";
+    if (nextResult.kind === "found") {
+      candidatesText = nextResult.candidates.map(
+        (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type}, phase: ${c.ticket.phase ?? "unphased"})${c.unblockImpact.wouldUnblock.length > 0 ? ` \u2014 unblocks ${c.unblockImpact.wouldUnblock.map((t) => t.id).join(", ")}` : ""}`
+      ).join("\n");
+    } else if (nextResult.kind === "all_complete") {
+      candidatesText = "All tickets are complete. No work to do.";
+    } else if (nextResult.kind === "all_blocked") {
+      candidatesText = "All remaining tickets are blocked.";
+    } else {
+      candidatesText = "No tickets found.";
+    }
+    const recResult = recommend(projectState, 5);
+    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(
+          (r) => `- ${r.id}: ${r.title} (${r.reason})`
+        ).join("\n");
+      }
+    }
+    updated = refreshLease(updated);
+    const pressure = evaluatePressure(updated);
+    updated = { ...updated, contextPressure: { ...updated.contextPressure, level: pressure } };
+    const written = writeSessionSync(dir, updated);
+    appendEvent(dir, {
+      rev: written.revision,
+      type: "start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { recipe, branch: written.git.branch, head: written.git.initHead }
+    });
+    const instruction = [
+      "# Autonomous Session Started",
+      "",
+      "I've loaded your project context and found ticket candidates.",
+      "",
+      "## Ticket Candidates",
+      "",
+      candidatesText,
+      recsText,
+      "",
+      "Pick a ticket by calling `claudestory_autonomous_guide` with:",
+      "```json",
+      `{ "sessionId": "${updated.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "T-XXX" } }`,
+      "```",
+      "",
+      "Replace T-XXX with the ticket ID you want to work on."
+    ].join("\n");
+    return guideResult(updated, "PICK_TICKET", {
+      instruction,
+      reminders: [
+        "Do NOT use Claude Code's plan mode \u2014 write plans as markdown files.",
+        "Do NOT ask the user for confirmation or approval.",
+        "Call autonomous_guide after completing each step."
+      ],
+      transitionedFrom: "INIT"
+    });
+  } catch (err) {
+    deleteSession(root, session.sessionId);
+    throw err;
+  }
+}
+async function handleReport(root, args) {
+  if (!args.sessionId) return guideError(new Error("sessionId is required for report action"));
+  if (!args.report) return guideError(new Error("report field is required for report action"));
+  const info = findSessionById(root, args.sessionId);
+  if (!info) return guideError(new Error(`Session ${args.sessionId} not found`));
+  let state = refreshLease(info.state);
+  const currentState = state.state;
+  const report = args.report;
+  switch (currentState) {
+    case "PICK_TICKET":
+      return handleReportPickTicket(root, info.dir, state, report);
+    case "PLAN":
+      return handleReportPlan(root, info.dir, state, report);
+    case "PLAN_REVIEW":
+      return handleReportPlanReview(root, info.dir, state, report);
+    case "IMPLEMENT":
+      return handleReportImplement(root, info.dir, state, report);
+    case "CODE_REVIEW":
+      return handleReportCodeReview(root, info.dir, state, report);
+    case "FINALIZE":
+      return handleReportFinalize(root, info.dir, state, report);
+    case "COMPLETE":
+      return handleReportComplete(root, info.dir, state, report);
+    case "HANDOVER":
+      return handleReportHandover(root, info.dir, state, report);
+    default:
+      return guideError(new Error(`Cannot report at state ${currentState}`));
+  }
+}
+async function handleReportPickTicket(root, dir, state, report) {
+  const ticketId = report.ticketId;
+  if (!ticketId) return guideError(new Error("report.ticketId is required when picking a ticket"));
+  const { state: projectState } = await loadProject(root);
+  const ticket = projectState.ticketByID(ticketId);
+  if (!ticket) return guideError(new Error(`Ticket ${ticketId} not found`));
+  if (projectState.isBlocked(ticket)) return guideError(new Error(`Ticket ${ticketId} is blocked`));
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: "PLAN",
+    previousState: "PICK_TICKET",
+    ticket: { id: ticket.id, title: ticket.title, claimed: true }
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "ticket_picked",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { ticketId: ticket.id, title: ticket.title }
+  });
+  return guideResult(written, "PLAN", {
+    instruction: [
+      `# Plan for ${ticket.id}: ${ticket.title}`,
+      "",
+      ticket.description ? `## Ticket Description
+
+${ticket.description}` : "",
+      "",
+      `Write an implementation plan for this ticket. Save it to \`.story/sessions/${state.sessionId}/plan.md\`.`,
+      "",
+      "When done, call `claudestory_autonomous_guide` with:",
+      "```json",
+      `{ "sessionId": "${state.sessionId}", "action": "report", "report": { "completedAction": "plan_written" } }`,
+      "```"
+    ].join("\n"),
+    reminders: [
+      "Write the plan as a markdown file \u2014 do NOT use Claude Code's plan mode.",
+      "Do NOT ask the user for approval."
+    ],
+    transitionedFrom: "PICK_TICKET"
+  });
+}
+async function handleReportPlan(root, dir, state, report) {
+  const planPath = join7(dir, "plan.md");
+  if (!existsSync7(planPath)) {
+    return guideResult(state, "PLAN", {
+      instruction: `Plan file not found at ${planPath}. Write your plan there and call me again.`,
+      reminders: ["Save plan to .story/sessions/<id>/plan.md"]
+    });
+  }
+  const planContent = readFileSafe(planPath);
+  if (!planContent || planContent.trim().length === 0) {
+    return guideResult(state, "PLAN", {
+      instruction: "Plan file is empty. Write your implementation plan and call me again.",
+      reminders: []
+    });
+  }
+  const risk = assessRisk(void 0, void 0);
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: "PLAN_REVIEW",
+    previousState: "PLAN",
+    ticket: state.ticket ? { ...state.ticket, risk } : state.ticket
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "plan_written",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { planLength: planContent.length, risk }
+  });
+  const backends = state.config.reviewBackends;
+  const reviewer = nextReviewer([], backends);
+  const rounds = requiredRounds(risk);
+  return guideResult(written, "PLAN_REVIEW", {
+    instruction: [
+      `# Plan Review \u2014 Round 1 of ${rounds} minimum`,
+      "",
+      `Run a plan review using **${reviewer}**.`,
+      "",
+      reviewer === "codex" ? `Call \`review_plan\` MCP tool with the plan content.` : `Launch a code review agent to review the plan.`,
+      "",
+      "When done, call `claudestory_autonomous_guide` with:",
+      "```json",
+      `{ "sessionId": "${state.sessionId}", "action": "report", "report": { "completedAction": "plan_review_round", "verdict": "<approve|revise|reject>", "findings": [...] } }`,
+      "```"
+    ].join("\n"),
+    reminders: ["Report the exact verdict and findings from the reviewer."],
+    transitionedFrom: "PLAN"
+  });
+}
+async function handleReportPlanReview(root, dir, state, report) {
+  const verdict = report.verdict;
+  if (!verdict || !["approve", "revise", "request_changes", "reject"].includes(verdict)) {
+    return guideResult(state, "PLAN_REVIEW", {
+      instruction: 'Invalid verdict. Re-submit with verdict: "approve", "revise", "request_changes", or "reject".',
+      reminders: []
+    });
+  }
+  const planReviews = [...state.reviews.plan];
+  const roundNum = planReviews.length + 1;
+  const findings = report.findings ?? [];
+  const backends = state.config.reviewBackends;
+  const reviewerBackend = nextReviewer(planReviews, backends);
+  planReviews.push({
+    round: roundNum,
+    reviewer: reviewerBackend,
+    verdict,
+    findingCount: findings.length,
+    criticalCount: findings.filter((f) => f.severity === "critical").length,
+    majorCount: findings.filter((f) => f.severity === "major").length,
+    suggestionCount: findings.filter((f) => f.severity === "suggestion").length,
+    codexSessionId: report.reviewerSessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const risk = state.ticket?.risk ?? "low";
+  const minRounds = requiredRounds(risk);
+  const hasCriticalOrMajor = findings.some(
+    (f) => f.severity === "critical" || f.severity === "major"
+  );
+  let nextState;
+  if (verdict === "reject") {
+    nextState = "PLAN";
+  } else if (verdict === "approve" || !hasCriticalOrMajor && roundNum >= minRounds) {
+    nextState = "IMPLEMENT";
+  } else if (roundNum >= 5) {
+    nextState = "IMPLEMENT";
+  } else {
+    nextState = "PLAN_REVIEW";
+  }
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: nextState,
+    previousState: "PLAN_REVIEW",
+    reviews: { ...state.reviews, plan: planReviews }
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "plan_review",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { round: roundNum, verdict, findingCount: findings.length }
+  });
+  if (nextState === "PLAN") {
+    return guideResult(written, "PLAN", {
+      instruction: 'Plan was rejected. Revise and rewrite the plan, then call me with completedAction: "plan_written".',
+      reminders: [],
+      transitionedFrom: "PLAN_REVIEW"
+    });
+  }
+  if (nextState === "IMPLEMENT") {
+    return guideResult(written, "IMPLEMENT", {
+      instruction: [
+        "# Implement",
+        "",
+        "Plan review passed. Implement the plan now.",
+        "",
+        "When done, call `claudestory_autonomous_guide` with:",
+        "```json",
+        `{ "sessionId": "${state.sessionId}", "action": "report", "report": { "completedAction": "implementation_done" } }`,
+        "```"
+      ].join("\n"),
+      reminders: ["Call autonomous_guide when implementation is complete."],
+      transitionedFrom: "PLAN_REVIEW"
+    });
+  }
+  const reviewer = nextReviewer(planReviews, backends);
+  return guideResult(written, "PLAN_REVIEW", {
+    instruction: [
+      `# Plan Review \u2014 Round ${roundNum + 1}`,
+      "",
+      hasCriticalOrMajor ? `Round ${roundNum} found ${findings.filter((f) => f.severity === "critical" || f.severity === "major").length} critical/major finding(s). Address them, then re-review with **${reviewer}**.` : `Round ${roundNum} complete. Run round ${roundNum + 1} with **${reviewer}**.`,
+      "",
+      "Report verdict and findings as before."
+    ].join("\n"),
+    reminders: ["Address findings before re-reviewing."]
+  });
+}
+async function handleReportImplement(root, dir, state, report) {
+  let realizedRisk = state.ticket?.risk ?? "low";
+  const mergeBase = state.git.mergeBase;
+  if (mergeBase) {
+    const diffResult = await gitDiffStat(root, mergeBase);
+    const namesResult = await gitDiffNames(root, mergeBase);
+    if (diffResult.ok) {
+      realizedRisk = assessRisk(diffResult.data, namesResult.ok ? namesResult.data : void 0);
+    }
+  }
+  const backends = state.config.reviewBackends;
+  const codeReviews = state.reviews.code;
+  const reviewer = nextReviewer(codeReviews, backends);
+  const rounds = requiredRounds(realizedRisk);
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: "CODE_REVIEW",
+    previousState: "IMPLEMENT",
+    ticket: state.ticket ? { ...state.ticket, realizedRisk } : state.ticket
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "implementation_done",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { realizedRisk }
+  });
+  return guideResult(written, "CODE_REVIEW", {
+    instruction: [
+      `# Code Review \u2014 Round 1 of ${rounds} minimum`,
+      "",
+      `Realized risk: **${realizedRisk}**${realizedRisk !== state.ticket?.risk ? ` (was ${state.ticket?.risk})` : ""}.`,
+      "",
+      `Run a code review using **${reviewer}**. Capture the git diff and pass it to the reviewer.`,
+      "",
+      "When done, report verdict and findings."
+    ].join("\n"),
+    reminders: ["Capture diff with `git diff` and pass to reviewer."],
+    transitionedFrom: "IMPLEMENT"
+  });
+}
+async function handleReportCodeReview(root, dir, state, report) {
+  const verdict = report.verdict;
+  if (!verdict || !["approve", "revise", "request_changes", "reject"].includes(verdict)) {
+    return guideResult(state, "CODE_REVIEW", {
+      instruction: 'Invalid verdict. Re-submit with verdict: "approve", "revise", "request_changes", or "reject".',
+      reminders: []
+    });
+  }
+  const codeReviews = [...state.reviews.code];
+  const roundNum = codeReviews.length + 1;
+  const findings = report.findings ?? [];
+  const backends = state.config.reviewBackends;
+  const reviewerBackend = nextReviewer(codeReviews, backends);
+  codeReviews.push({
+    round: roundNum,
+    reviewer: reviewerBackend,
+    verdict,
+    findingCount: findings.length,
+    criticalCount: findings.filter((f) => f.severity === "critical").length,
+    majorCount: findings.filter((f) => f.severity === "major").length,
+    suggestionCount: findings.filter((f) => f.severity === "suggestion").length,
+    codexSessionId: report.reviewerSessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const risk = state.ticket?.realizedRisk ?? state.ticket?.risk ?? "low";
+  const minRounds = requiredRounds(risk);
+  const hasCriticalOrMajor = findings.some(
+    (f) => f.severity === "critical" || f.severity === "major"
+  );
+  const planRedirect = findings.some((f) => f.recommendedNextState === "PLAN");
+  let nextState;
+  if (verdict === "reject" && planRedirect) {
+    nextState = "PLAN";
+  } else if (verdict === "reject") {
+    nextState = "IMPLEMENT";
+  } else if (verdict === "approve" || !hasCriticalOrMajor && roundNum >= minRounds) {
+    nextState = "FINALIZE";
+  } else if (roundNum >= 5) {
+    nextState = "FINALIZE";
+  } else {
+    nextState = "CODE_REVIEW";
+  }
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: nextState,
+    previousState: "CODE_REVIEW",
+    reviews: { ...state.reviews, code: codeReviews }
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "code_review",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { round: roundNum, verdict, findingCount: findings.length }
+  });
+  if (nextState === "PLAN") {
+    return guideResult(written, "PLAN", {
+      instruction: 'Code review recommends rethinking the approach. Revise the plan and call me with completedAction: "plan_written".',
+      reminders: [],
+      transitionedFrom: "CODE_REVIEW"
+    });
+  }
+  if (nextState === "IMPLEMENT") {
+    return guideResult(written, "IMPLEMENT", {
+      instruction: 'Code review requested changes. Fix the issues and call me with completedAction: "implementation_done".',
+      reminders: ["Address all critical/major findings before re-submitting."],
+      transitionedFrom: "CODE_REVIEW"
+    });
+  }
+  if (nextState === "FINALIZE") {
+    return guideResult(written, "FINALIZE", {
+      instruction: [
+        "# Finalize",
+        "",
+        "Code review passed. Time to commit.",
+        "",
+        state.ticket ? `1. Update ticket ${state.ticket.id} status to "complete" in .story/` : "",
+        "2. Stage all changed files (code + .story/ changes)",
+        '3. Call me with completedAction: "files_staged"'
+      ].filter(Boolean).join("\n"),
+      reminders: ["Stage both code changes and .story/ ticket update in the same commit."],
+      transitionedFrom: "CODE_REVIEW"
+    });
+  }
+  const reviewer = nextReviewer(codeReviews, backends);
+  return guideResult(written, "CODE_REVIEW", {
+    instruction: `Code review round ${roundNum} found issues. Fix them and re-review with **${reviewer}**.`,
+    reminders: []
+  });
+}
+async function handleReportFinalize(root, dir, state, report) {
+  const action = report.completedAction;
+  const checkpoint = state.finalizeCheckpoint;
+  if (action === "files_staged" && (!checkpoint || checkpoint === "staged")) {
+    const stagedResult = await gitDiffCachedNames(root);
+    if (!stagedResult.ok || stagedResult.data.length === 0) {
+      return guideResult(state, "FINALIZE", {
+        instruction: 'No files are staged. Stage your changes and call me again with completedAction: "files_staged".',
+        reminders: []
+      });
+    }
+    const written = writeSessionSync(dir, { ...state, finalizeCheckpoint: "staged" });
+    return guideResult(written, "FINALIZE", {
+      instruction: [
+        "Files staged. Now run pre-commit checks.",
+        "",
+        '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."]
+    });
+  }
+  if (action === "precommit_passed") {
+    if (!checkpoint || checkpoint === null) {
+      return guideResult(state, "FINALIZE", {
+        instruction: 'You must stage files first. Call me with completedAction: "files_staged" after staging.',
+        reminders: []
+      });
+    }
+    const stagedResult = await gitDiffCachedNames(root);
+    if (!stagedResult.ok || stagedResult.data.length === 0) {
+      const written2 = writeSessionSync(dir, { ...state, finalizeCheckpoint: null });
+      return guideResult(written2, "FINALIZE", {
+        instruction: 'Pre-commit hooks appear to have cleared the staging area. Re-stage your changes and call me with completedAction: "files_staged".',
+        reminders: []
+      });
+    }
+    const written = writeSessionSync(dir, { ...state, finalizeCheckpoint: "precommit_passed" });
+    return guideResult(written, "FINALIZE", {
+      instruction: [
+        "Pre-commit passed. Now commit.",
+        "",
+        state.ticket ? `Commit with message: "feat: <description> (${state.ticket.id})"` : "Commit with a descriptive message.",
+        "",
+        'Call me with completedAction: "commit_done" and include the commitHash.'
+      ].join("\n"),
+      reminders: []
+    });
+  }
+  if (action === "commit_done") {
+    if (!checkpoint || checkpoint === null) {
+      return guideResult(state, "FINALIZE", {
+        instruction: 'You must stage files first. Call me with completedAction: "files_staged" after staging.',
+        reminders: []
+      });
+    }
+    if (checkpoint === "staged") {
+      return guideResult(state, "FINALIZE", {
+        instruction: 'You must pass pre-commit checks first. Call me with completedAction: "precommit_passed".',
+        reminders: []
+      });
+    }
+    if (checkpoint === "committed") {
+      return guideResult(state, "FINALIZE", {
+        instruction: "Commit was already recorded. Proceeding to completion.",
+        reminders: []
+      });
+    }
+    const commitHash = report.commitHash;
+    if (!commitHash) {
+      return guideResult(state, "FINALIZE", {
+        instruction: "Missing commitHash in report. Call me again with the commit hash.",
+        reminders: []
+      });
+    }
+    const completedTicket = state.ticket ? { id: state.ticket.id, title: state.ticket.title, commitHash, risk: state.ticket.risk } : void 0;
+    const updated = {
+      ...state,
+      state: "COMPLETE",
+      previousState: "FINALIZE",
+      finalizeCheckpoint: "committed",
+      completedTickets: completedTicket ? [...state.completedTickets, completedTicket] : state.completedTickets,
+      ticket: void 0
+    };
+    const written = writeSessionSync(dir, updated);
+    appendEvent(dir, {
+      rev: written.revision,
+      type: "commit",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { commitHash, ticketId: completedTicket?.id }
+    });
+    return handleReportComplete(root, dir, refreshLease(written), { completedAction: "commit_done" });
+  }
+  return guideResult(state, "FINALIZE", {
+    instruction: 'Unexpected action at FINALIZE. Stage files and call with completedAction: "files_staged", or commit and call with completedAction: "commit_done".',
+    reminders: []
+  });
+}
+async function handleReportComplete(root, dir, state, report) {
+  const pressure = evaluatePressure(state);
+  const updated = {
+    ...state,
+    state: "COMPLETE",
+    contextPressure: { ...state.contextPressure, level: pressure },
+    finalizeCheckpoint: null
+  };
+  const ticketsDone = updated.completedTickets.length;
+  const maxTickets = updated.config.maxTicketsPerSession;
+  let nextState;
+  let advice = "ok";
+  if (pressure === "critical") {
+    nextState = "HANDOVER";
+    advice = "compact-now";
+  } else if (ticketsDone >= maxTickets) {
+    nextState = "HANDOVER";
+  } else if (pressure === "high") {
+    advice = "consider-compact";
+    nextState = "PICK_TICKET";
+  } else {
+    nextState = "PICK_TICKET";
+  }
+  const { state: projectState } = await loadProject(root);
+  const nextResult = nextTickets(projectState, 1);
+  if (nextResult.kind !== "found") {
+    nextState = "HANDOVER";
+  }
+  const transitioned = writeSessionSync(dir, {
+    ...updated,
+    state: nextState,
+    previousState: "COMPLETE"
+  });
+  if (nextState === "HANDOVER") {
+    return guideResult(transitioned, "HANDOVER", {
+      instruction: [
+        `# Session Complete \u2014 ${ticketsDone} ticket(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: [],
+      transitionedFrom: "COMPLETE",
+      contextAdvice: advice
+    });
+  }
+  const candidates = nextTickets(projectState, 5);
+  let candidatesText = "";
+  if (candidates.kind === "found") {
+    candidatesText = candidates.candidates.map(
+      (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type})`
+    ).join("\n");
+  }
+  return guideResult(transitioned, "PICK_TICKET", {
+    instruction: [
+      `# Ticket Complete \u2014 Pick Next (${ticketsDone}/${maxTickets})`,
+      "",
+      candidatesText,
+      "",
+      'Pick a ticket by calling me with completedAction: "ticket_picked" and ticketId.'
+    ].join("\n"),
+    reminders: [],
+    transitionedFrom: "COMPLETE",
+    contextAdvice: advice
+  });
+}
+async function handleReportHandover(root, dir, state, report) {
+  const content = report.handoverContent;
+  if (!content) {
+    return guideResult(state, "HANDOVER", {
+      instruction: "Missing handoverContent. Write the handover and include it in the report.",
+      reminders: []
+    });
+  }
+  let handoverFailed = false;
+  try {
+    await handleHandoverCreate(content, "auto-session", "md", root);
+  } catch (err) {
+    handoverFailed = true;
+    try {
+      const fallbackPath = join7(dir, "handover-fallback.md");
+      writeFileSync2(fallbackPath, content, "utf-8");
+    } catch {
+    }
+  }
+  const written = writeSessionSync(dir, {
+    ...state,
+    state: "SESSION_END",
+    previousState: "HANDOVER",
+    status: "completed"
+  });
+  appendEvent(dir, {
+    rev: written.revision,
+    type: "session_end",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { ticketsCompleted: written.completedTickets.length, handoverFailed }
+  });
+  const ticketsDone = written.completedTickets.length;
+  return guideResult(written, "SESSION_END", {
+    instruction: [
+      "# Session Complete",
+      "",
+      `${ticketsDone} ticket(s) completed.${handoverFailed ? " Handover creation failed \u2014 fallback saved to session directory." : " Handover written."} Session ended.`,
+      "",
+      written.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n")
+    ].join("\n"),
+    reminders: [],
+    transitionedFrom: "HANDOVER"
+  });
+}
+async function handleResume(root, args) {
+  if (!args.sessionId) return guideError(new Error("sessionId is required for resume"));
+  const info = findSessionById(root, args.sessionId);
+  if (!info) return guideError(new Error(`Session ${args.sessionId} not found`));
+  if (info.state.state !== "COMPACT") {
+    return guideError(new Error(
+      `Session ${args.sessionId} is not in COMPACT state (current: ${info.state.state}). Use action: "report" to continue.`
+    ));
+  }
+  const resumeState = info.state.preCompactState;
+  if (!resumeState || !WORKFLOW_STATES.includes(resumeState)) {
+    return guideError(new Error(
+      `Session ${args.sessionId} has invalid preCompactState: ${resumeState}. Cannot resume safely.`
+    ));
+  }
+  const written = writeSessionSync(info.dir, {
+    ...refreshLease(info.state),
+    state: resumeState,
+    preCompactState: null,
+    resumeFromRevision: null,
+    contextPressure: { ...info.state.contextPressure, compactionCount: (info.state.contextPressure?.compactionCount ?? 0) + 1 }
+  });
+  return guideResult(written, resumeState, {
+    instruction: [
+      "# Resumed After Compact",
+      "",
+      `Session restored at state: **${resumeState}**.`,
+      written.ticket ? `Working on: **${written.ticket.id}: ${written.ticket.title}**` : "No ticket in progress.",
+      "",
+      "Continue where you left off. Call me when you complete the current step."
+    ].join("\n"),
+    reminders: [
+      "Do NOT use plan mode.",
+      "Call autonomous_guide after completing each step."
+    ]
+  });
+}
+async function handlePreCompact(root, args) {
+  if (!args.sessionId) return guideError(new Error("sessionId is required for pre_compact"));
+  const info = findSessionById(root, args.sessionId);
+  if (!info) return guideError(new Error(`Session ${args.sessionId} not found`));
+  if (info.state.state === "SESSION_END") {
+    return guideError(new Error(`Session ${args.sessionId} is already ended and cannot be compacted.`));
+  }
+  if (info.state.state === "COMPACT") {
+    return guideError(new Error(`Session ${args.sessionId} is already in COMPACT state. Call action: "resume" to continue.`));
+  }
+  const headResult = await gitHead(root);
+  const written = writeSessionSync(info.dir, {
+    ...refreshLease(info.state),
+    state: "COMPACT",
+    previousState: info.state.state,
+    preCompactState: info.state.state,
+    resumeFromRevision: info.state.revision,
+    git: {
+      ...info.state.git,
+      expectedHead: headResult.ok ? headResult.data.hash : info.state.git.expectedHead
+    }
+  });
+  try {
+    const loadResult = await loadProject(root);
+    const { saveSnapshot: saveSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+    await saveSnapshot2(root, loadResult);
+  } catch {
+  }
+  return guideResult(written, "COMPACT", {
+    instruction: [
+      "# Ready for Compact",
+      "",
+      "State flushed. Run `/compact` now.",
+      "",
+      "After compact, call `claudestory_autonomous_guide` with:",
+      "```json",
+      `{ "sessionId": "${written.sessionId}", "action": "resume" }`,
+      "```"
+    ].join("\n"),
+    reminders: []
+  });
+}
+async function handleCancel(root, args) {
+  if (!args.sessionId) {
+    const active = findActiveSessionFull(root);
+    if (!active) return guideError(new Error("No active session to cancel"));
+    args = { ...args, sessionId: active.state.sessionId };
+  }
+  const info = findSessionById(root, args.sessionId);
+  if (!info) return guideError(new Error(`Session ${args.sessionId} not found`));
+  const written = writeSessionSync(info.dir, {
+    ...info.state,
+    state: "SESSION_END",
+    previousState: info.state.state,
+    status: "completed"
+  });
+  appendEvent(info.dir, {
+    rev: written.revision,
+    type: "cancelled",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: { previousState: info.state.state }
+  });
+  return {
+    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) were completed.` }]
+  };
+}
+function guideResult(state, currentState, opts) {
+  const summary = {
+    ticket: state.ticket ? `${state.ticket.id}: ${state.ticket.title}` : "none",
+    risk: state.ticket?.risk ?? "unknown",
+    completed: state.completedTickets.map((t) => t.id),
+    currentStep: currentState,
+    contextPressure: state.contextPressure?.level ?? "low",
+    branch: state.git?.branch ?? null
+  };
+  const output = {
+    sessionId: state.sessionId,
+    state: currentState,
+    transitionedFrom: opts.transitionedFrom,
+    instruction: opts.instruction,
+    reminders: opts.reminders ?? [],
+    contextAdvice: opts.contextAdvice ?? "ok",
+    sessionSummary: summary
+  };
+  const parts = [
+    output.instruction,
+    "",
+    "---",
+    `**Session:** ${output.sessionId}`,
+    `**State:** ${output.state}${output.transitionedFrom ? ` (from ${output.transitionedFrom})` : ""}`,
+    `**Ticket:** ${summary.ticket}`,
+    `**Risk:** ${summary.risk}`,
+    `**Completed:** ${summary.completed.length > 0 ? summary.completed.join(", ") : "none"}`,
+    `**Pressure:** ${summary.contextPressure}`,
+    summary.branch ? `**Branch:** ${summary.branch}` : "",
+    output.contextAdvice !== "ok" ? `**Context:** ${output.contextAdvice}` : "",
+    output.reminders.length > 0 ? `
+**Reminders:**
+${output.reminders.map((r) => `- ${r}`).join("\n")}` : ""
+  ].filter(Boolean);
+  return { content: [{ type: "text", text: parts.join("\n") }] };
+}
+function guideError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    content: [{ type: "text", text: `[autonomous_guide error] ${message}` }],
+    isError: true
+  };
+}
+function readFileSafe(path2) {
+  try {
+    return readFileSync2(path2, "utf-8");
+  } catch {
+    return "";
+  }
+}
+var workspaceLocks;
+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_project_loader();
+    init_snapshot();
+    init_snapshot();
+    init_queries();
+    init_recommend();
+    init_handover();
+    workspaceLocks = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/cli/commands/phase.ts
+import { join as join8, 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`);
+  }
+  if (!PHASE_ID_REGEX.test(id)) {
+    throw new CliValidationError("invalid_input", `Phase ID "${id}" must be lowercase alphanumeric with hyphens (e.g. "my-phase")`);
+  }
+}
+function handlePhaseList(ctx) {
+  return { output: formatPhaseList(ctx.state, ctx.format) };
+}
+function handlePhaseCurrent(ctx) {
+  const phase = currentPhase(ctx.state);
+  if (phase) {
+    if (ctx.format === "json") {
+      return { output: JSON.stringify(successEnvelope(phase), null, 2) };
+    }
+    const summary = phase.summary ?? phase.description;
+    return { output: `${phase.name} (${phase.id}) \u2014 ${summary}` };
+  }
+  const hasLeavesInAnyPhase = ctx.state.roadmap.phases.some(
+    (p) => ctx.state.phaseTickets(p.id).length > 0
+  );
+  if (!hasLeavesInAnyPhase) {
+    if (ctx.format === "json") {
+      return {
+        output: JSON.stringify(successEnvelope({ current: null, reason: "no_phases" }), null, 2),
+        exitCode: ExitCode.USER_ERROR
+      };
+    }
+    return {
+      output: "No phases with tickets defined.",
+      exitCode: ExitCode.USER_ERROR
+    };
+  }
+  if (ctx.format === "json") {
+    return {
+      output: JSON.stringify(successEnvelope({ current: null, reason: "all_complete" }), null, 2)
+    };
+  }
+  return { output: "All phases complete." };
+}
+function handlePhaseTickets(phaseId, ctx) {
+  const phaseExists = ctx.state.roadmap.phases.some((p) => p.id === phaseId);
+  if (!phaseExists) {
+    return {
+      output: formatError("not_found", `Phase "${phaseId}" not found`, ctx.format),
+      exitCode: ExitCode.USER_ERROR,
+      errorCode: "not_found"
+    };
+  }
+  return { output: formatPhaseTickets(phaseId, ctx.state, ctx.format) };
+}
+async function handlePhaseCreate(args, format, root) {
+  validatePhaseId(args.id);
+  if (args.atStart && args.after) {
+    throw new CliValidationError("invalid_input", "Cannot use both --after and --at-start");
+  }
+  if (!args.atStart && !args.after) {
+    throw new CliValidationError("invalid_input", "Must specify either --after <phase-id> or --at-start");
+  }
+  let createdPhase;
+  await withProjectLock(root, { strict: true }, async ({ state }) => {
+    if (state.roadmap.phases.some((p) => p.id === args.id)) {
+      throw new CliValidationError("conflict", `Phase "${args.id}" already exists`);
+    }
+    const phase = {
+      id: args.id,
+      label: args.label,
+      name: args.name,
+      description: args.description,
+      ...args.summary !== void 0 && { summary: args.summary }
+    };
+    const newPhases = [...state.roadmap.phases];
+    if (args.atStart) {
+      newPhases.unshift(phase);
+    } else {
+      const afterIdx = newPhases.findIndex((p) => p.id === args.after);
+      if (afterIdx < 0) {
+        throw new CliValidationError("not_found", `Phase "${args.after}" not found`);
+      }
+      newPhases.splice(afterIdx + 1, 0, phase);
+    }
+    const newRoadmap = { ...state.roadmap, phases: newPhases };
+    await writeRoadmapUnlocked(newRoadmap, root);
+    createdPhase = phase;
+  });
+  if (!createdPhase) throw new Error("Phase not created");
+  if (format === "json") {
+    return { output: JSON.stringify(successEnvelope(createdPhase), null, 2) };
+  }
+  return { output: `Created phase ${createdPhase.id}: ${createdPhase.name}` };
+}
+async function handlePhaseRename(id, updates, format, root) {
+  let updatedPhase;
+  await withProjectLock(root, { strict: true }, async ({ state }) => {
+    const idx = state.roadmap.phases.findIndex((p) => p.id === id);
+    if (idx < 0) {
+      throw new CliValidationError("not_found", `Phase "${id}" not found`);
+    }
+    const existing = state.roadmap.phases[idx];
+    const phase = {
+      ...existing,
+      ...updates.name !== void 0 && { name: updates.name },
+      ...updates.label !== void 0 && { label: updates.label },
+      ...updates.description !== void 0 && { description: updates.description },
+      ...updates.summary !== void 0 && { summary: updates.summary }
+    };
     const newPhases = [...state.roadmap.phases];
     newPhases[idx] = phase;
     const newRoadmap = { ...state.roadmap, phases: newPhases };
@@ -4195,21 +6038,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 = join6(wrapDir, "tickets", `${parsed.id}.json`);
+        const target = join8(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 = join6(wrapDir, "issues", `${parsed.id}.json`);
+        const target = join8(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 = join6(wrapDir, "roadmap.json");
+      const roadmapTarget = join8(wrapDir, "roadmap.json");
       operations.push({ op: "write", target: roadmapTarget, content: roadmapContent });
       await runTransactionUnlocked(root, operations);
     } else {
@@ -4241,15 +6084,15 @@ var init_phase = __esm({
 });
 
 // src/mcp/tools.ts
-import { z as z8 } from "zod";
-import { join as join7 } from "path";
+import { z as z9 } from "zod";
+import { join as join9 } from "path";
 function formatMcpError(code, message) {
   return `[${code}] ${message}`;
 }
 async function runMcpReadTool(pinnedRoot, handler) {
   try {
     const { state, warnings } = await loadProject(pinnedRoot);
-    const handoversDir = join7(pinnedRoot, ".story", "handovers");
+    const handoversDir = join9(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)) {
@@ -4313,7 +6156,7 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_ticket_next", {
     description: "Highest-priority unblocked ticket(s) with unblock impact and umbrella progress",
     inputSchema: {
-      count: z8.number().int().min(1).max(10).optional().describe("Number of candidates to return (default: 1)")
+      count: z9.number().int().min(1).max(10).optional().describe("Number of candidates to return (default: 1)")
     }
   }, (args) => runMcpReadTool(
     pinnedRoot,
@@ -4328,7 +6171,7 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_handover_latest", {
     description: "Content of the most recent handover document(s)",
     inputSchema: {
-      count: z8.number().int().min(1).max(10).optional().describe("Number of recent handovers to return (default: 1)")
+      count: z9.number().int().min(1).max(10).optional().describe("Number of recent handovers to return (default: 1)")
     }
   }, (args) => runMcpReadTool(
     pinnedRoot,
@@ -4343,7 +6186,7 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_phase_tickets", {
     description: "Leaf tickets for a specific phase, sorted by order",
     inputSchema: {
-      phaseId: z8.string().describe("Phase ID (e.g. p5b, dogfood)")
+      phaseId: z9.string().describe("Phase ID (e.g. p5b, dogfood)")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => {
     const phaseExists = ctx.state.roadmap.phases.some((p) => p.id === args.phaseId);
@@ -4359,9 +6202,9 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_ticket_list", {
     description: "List leaf tickets with optional filters",
     inputSchema: {
-      status: z8.enum(TICKET_STATUSES).optional().describe("Filter by status: open, inprogress, complete"),
-      phase: z8.string().optional().describe("Filter by phase ID"),
-      type: z8.enum(TICKET_TYPES).optional().describe("Filter by type: task, feature, chore")
+      status: z9.enum(TICKET_STATUSES).optional().describe("Filter by status: open, inprogress, complete"),
+      phase: z9.string().optional().describe("Filter by phase ID"),
+      type: z9.enum(TICKET_TYPES).optional().describe("Filter by type: task, feature, chore")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => {
     if (args.phase) {
@@ -4382,15 +6225,15 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_ticket_get", {
     description: "Get a ticket by ID (includes umbrella tickets)",
     inputSchema: {
-      id: z8.string().regex(TICKET_ID_REGEX).describe("Ticket ID (e.g. T-001, T-079b)")
+      id: z9.string().regex(TICKET_ID_REGEX).describe("Ticket ID (e.g. T-001, T-079b)")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => handleTicketGet(args.id, ctx)));
   server.registerTool("claudestory_issue_list", {
     description: "List issues with optional filters",
     inputSchema: {
-      status: z8.enum(ISSUE_STATUSES).optional().describe("Filter by status: open, inprogress, resolved"),
-      severity: z8.enum(ISSUE_SEVERITIES).optional().describe("Filter by severity: critical, high, medium, low"),
-      component: z8.string().optional().describe("Filter by component name")
+      status: z9.enum(ISSUE_STATUSES).optional().describe("Filter by status: open, inprogress, resolved"),
+      severity: z9.enum(ISSUE_SEVERITIES).optional().describe("Filter by severity: critical, high, medium, low"),
+      component: z9.string().optional().describe("Filter by component name")
     }
   }, (args) => runMcpReadTool(
     pinnedRoot,
@@ -4399,13 +6242,13 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_issue_get", {
     description: "Get an issue by ID",
     inputSchema: {
-      id: z8.string().regex(ISSUE_ID_REGEX).describe("Issue ID (e.g. ISS-001)")
+      id: z9.string().regex(ISSUE_ID_REGEX).describe("Issue ID (e.g. ISS-001)")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => handleIssueGet(args.id, ctx)));
   server.registerTool("claudestory_handover_get", {
     description: "Content of a specific handover document by filename",
     inputSchema: {
-      filename: z8.string().describe("Handover filename (e.g. 2026-03-20-session.md)")
+      filename: z9.string().describe("Handover filename (e.g. 2026-03-20-session.md)")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => handleHandoverGet(args.filename, ctx)));
   server.registerTool("claudestory_recap", {
@@ -4414,7 +6257,7 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_recommend", {
     description: "Context-aware ranked work suggestions mixing tickets and issues",
     inputSchema: {
-      count: z8.number().int().min(1).max(10).optional().describe("Number of recommendations (default: 5)")
+      count: z9.number().int().min(1).max(10).optional().describe("Number of recommendations (default: 5)")
     }
   }, (args) => runMcpReadTool(
     pinnedRoot,
@@ -4426,8 +6269,8 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_export", {
     description: "Self-contained project document for sharing",
     inputSchema: {
-      phase: z8.string().optional().describe("Export a single phase by ID"),
-      all: z8.boolean().optional().describe("Export entire project")
+      phase: z9.string().optional().describe("Export a single phase by ID"),
+      all: z9.boolean().optional().describe("Export entire project")
     }
   }, (args) => {
     if (!args.phase && !args.all) {
@@ -4449,8 +6292,8 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_handover_create", {
     description: "Create a handover document from markdown content",
     inputSchema: {
-      content: z8.string().describe("Markdown content of the handover"),
-      slug: z8.string().optional().describe("Slug for filename (e.g. phase5b-wrapup). Default: session")
+      content: z9.string().describe("Markdown content of the handover"),
+      slug: z9.string().optional().describe("Slug for filename (e.g. phase5b-wrapup). Default: session")
     }
   }, (args) => {
     if (!args.content?.trim()) {
@@ -4467,12 +6310,12 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_ticket_create", {
     description: "Create a new ticket",
     inputSchema: {
-      title: z8.string().describe("Ticket title"),
-      type: z8.enum(TICKET_TYPES).describe("Ticket type: task, feature, chore"),
-      phase: z8.string().optional().describe("Phase ID"),
-      description: z8.string().optional().describe("Ticket description"),
-      blockedBy: z8.array(z8.string().regex(TICKET_ID_REGEX)).optional().describe("IDs of blocking tickets"),
-      parentTicket: z8.string().regex(TICKET_ID_REGEX).optional().describe("Parent ticket ID (makes this a sub-ticket)")
+      title: z9.string().describe("Ticket title"),
+      type: z9.enum(TICKET_TYPES).describe("Ticket type: task, feature, chore"),
+      phase: z9.string().optional().describe("Phase ID"),
+      description: z9.string().optional().describe("Ticket description"),
+      blockedBy: z9.array(z9.string().regex(TICKET_ID_REGEX)).optional().describe("IDs of blocking tickets"),
+      parentTicket: z9.string().regex(TICKET_ID_REGEX).optional().describe("Parent ticket ID (makes this a sub-ticket)")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4492,14 +6335,15 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_ticket_update", {
     description: "Update an existing ticket",
     inputSchema: {
-      id: z8.string().regex(TICKET_ID_REGEX).describe("Ticket ID (e.g. T-001)"),
-      status: z8.enum(TICKET_STATUSES).optional().describe("New status: open, inprogress, complete"),
-      title: z8.string().optional().describe("New title"),
-      order: z8.number().optional().describe("New sort order"),
-      description: z8.string().optional().describe("New description"),
-      phase: z8.string().nullable().optional().describe("New phase ID (null to clear)"),
-      parentTicket: z8.string().regex(TICKET_ID_REGEX).nullable().optional().describe("Parent ticket ID (null to clear)"),
-      blockedBy: z8.array(z8.string().regex(TICKET_ID_REGEX)).optional().describe("IDs of blocking tickets")
+      id: z9.string().regex(TICKET_ID_REGEX).describe("Ticket ID (e.g. T-001)"),
+      status: z9.enum(TICKET_STATUSES).optional().describe("New status: open, inprogress, complete"),
+      title: z9.string().optional().describe("New title"),
+      type: z9.enum(TICKET_TYPES).optional().describe("New type: task, feature, chore"),
+      order: z9.number().int().optional().describe("New sort order"),
+      description: z9.string().optional().describe("New description"),
+      phase: z9.string().nullable().optional().describe("New phase ID (null to clear)"),
+      parentTicket: z9.string().regex(TICKET_ID_REGEX).nullable().optional().describe("Parent ticket ID (null to clear)"),
+      blockedBy: z9.array(z9.string().regex(TICKET_ID_REGEX)).optional().describe("IDs of blocking tickets")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4508,6 +6352,7 @@ function registerAllTools(server, pinnedRoot) {
       {
         status: args.status,
         title: args.title,
+        type: args.type,
         order: args.order,
         description: args.description,
         phase: args.phase,
@@ -4521,13 +6366,13 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_issue_create", {
     description: "Create a new issue",
     inputSchema: {
-      title: z8.string().describe("Issue title"),
-      severity: z8.enum(ISSUE_SEVERITIES).describe("Issue severity: critical, high, medium, low"),
-      impact: z8.string().describe("Impact description"),
-      components: z8.array(z8.string()).optional().describe("Affected components"),
-      relatedTickets: z8.array(z8.string().regex(TICKET_ID_REGEX)).optional().describe("Related ticket IDs"),
-      location: z8.array(z8.string()).optional().describe("File locations"),
-      phase: z8.string().optional().describe("Phase ID")
+      title: z9.string().describe("Issue title"),
+      severity: z9.enum(ISSUE_SEVERITIES).describe("Issue severity: critical, high, medium, low"),
+      impact: z9.string().describe("Impact description"),
+      components: z9.array(z9.string()).optional().describe("Affected components"),
+      relatedTickets: z9.array(z9.string().regex(TICKET_ID_REGEX)).optional().describe("Related ticket IDs"),
+      location: z9.array(z9.string()).optional().describe("File locations"),
+      phase: z9.string().optional().describe("Phase ID")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4548,15 +6393,17 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_issue_update", {
     description: "Update an existing issue",
     inputSchema: {
-      id: z8.string().regex(ISSUE_ID_REGEX).describe("Issue ID (e.g. ISS-001)"),
-      status: z8.enum(ISSUE_STATUSES).optional().describe("New status: open, inprogress, resolved"),
-      title: z8.string().optional().describe("New title"),
-      severity: z8.enum(ISSUE_SEVERITIES).optional().describe("New severity"),
-      impact: z8.string().optional().describe("New impact description"),
-      resolution: z8.string().nullable().optional().describe("Resolution description (null to clear)"),
-      components: z8.array(z8.string()).optional().describe("Affected components"),
-      relatedTickets: z8.array(z8.string().regex(TICKET_ID_REGEX)).optional().describe("Related ticket IDs"),
-      location: z8.array(z8.string()).optional().describe("File locations")
+      id: z9.string().regex(ISSUE_ID_REGEX).describe("Issue ID (e.g. ISS-001)"),
+      status: z9.enum(ISSUE_STATUSES).optional().describe("New status: open, inprogress, resolved"),
+      title: z9.string().optional().describe("New title"),
+      severity: z9.enum(ISSUE_SEVERITIES).optional().describe("New severity"),
+      impact: z9.string().optional().describe("New impact description"),
+      resolution: z9.string().nullable().optional().describe("Resolution description (null to clear)"),
+      components: z9.array(z9.string()).optional().describe("Affected components"),
+      relatedTickets: z9.array(z9.string().regex(TICKET_ID_REGEX)).optional().describe("Related ticket IDs"),
+      location: z9.array(z9.string()).optional().describe("File locations"),
+      order: z9.number().int().optional().describe("New sort order"),
+      phase: z9.string().nullable().optional().describe("New phase ID (null to clear)")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4570,7 +6417,9 @@ function registerAllTools(server, pinnedRoot) {
         resolution: args.resolution,
         components: args.components,
         relatedTickets: args.relatedTickets,
-        location: args.location
+        location: args.location,
+        order: args.order,
+        phase: args.phase
       },
       format,
       root
@@ -4579,8 +6428,8 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_note_list", {
     description: "List notes with optional status/tag filters",
     inputSchema: {
-      status: z8.enum(NOTE_STATUSES).optional().describe("Filter by status: active, archived"),
-      tag: z8.string().optional().describe("Filter by tag")
+      status: z9.enum(NOTE_STATUSES).optional().describe("Filter by status: active, archived"),
+      tag: z9.string().optional().describe("Filter by tag")
     }
   }, (args) => runMcpReadTool(
     pinnedRoot,
@@ -4589,15 +6438,15 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_note_get", {
     description: "Get a note by ID",
     inputSchema: {
-      id: z8.string().regex(NOTE_ID_REGEX).describe("Note ID (e.g. N-001)")
+      id: z9.string().regex(NOTE_ID_REGEX).describe("Note ID (e.g. N-001)")
     }
   }, (args) => runMcpReadTool(pinnedRoot, (ctx) => handleNoteGet(args.id, ctx)));
   server.registerTool("claudestory_note_create", {
     description: "Create a new note",
     inputSchema: {
-      content: z8.string().describe("Note content"),
-      title: z8.string().optional().describe("Note title"),
-      tags: z8.array(z8.string()).optional().describe("Tags for the note")
+      content: z9.string().describe("Note content"),
+      title: z9.string().optional().describe("Note title"),
+      tags: z9.array(z9.string()).optional().describe("Tags for the note")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4614,11 +6463,11 @@ function registerAllTools(server, pinnedRoot) {
   server.registerTool("claudestory_note_update", {
     description: "Update an existing note",
     inputSchema: {
-      id: z8.string().regex(NOTE_ID_REGEX).describe("Note ID (e.g. N-001)"),
-      content: z8.string().optional().describe("New content"),
-      title: z8.string().nullable().optional().describe("New title (null to clear)"),
-      tags: z8.array(z8.string()).optional().describe("New tags (replaces existing)"),
-      status: z8.enum(NOTE_STATUSES).optional().describe("New status: active, archived")
+      id: z9.string().regex(NOTE_ID_REGEX).describe("Note ID (e.g. N-001)"),
+      content: z9.string().optional().describe("New content"),
+      title: z9.string().nullable().optional().describe("New title (null to clear)"),
+      tags: z9.array(z9.string()).optional().describe("New tags (replaces existing)"),
+      status: z9.enum(NOTE_STATUSES).optional().describe("New status: active, archived")
     }
   }, (args) => runMcpWriteTool(
     pinnedRoot,
@@ -4633,122 +6482,103 @@ function registerAllTools(server, pinnedRoot) {
       },
       format,
       root
-    )
-  ));
-}
-var INFRASTRUCTURE_ERROR_CODES;
-var init_tools = __esm({
-  "src/mcp/tools.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_project_loader();
-    init_errors();
-    init_helpers();
-    init_types();
-    init_status();
-    init_validate();
-    init_handover();
-    init_blocker();
-    init_ticket2();
-    init_issue2();
-    init_recap();
-    init_note2();
-    init_recommend2();
-    init_snapshot2();
-    init_export();
-    init_handover();
-    init_phase();
-    INFRASTRUCTURE_ERROR_CODES = [
-      "io_error",
-      "project_corrupt",
-      "version_mismatch"
-    ];
-  }
-});
-
-// src/mcp/index.ts
-var mcp_exports = {};
-import { realpathSync, existsSync as existsSync6 } from "fs";
-import { resolve as resolve7, join as join8, isAbsolute } from "path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function tryDiscoverRoot() {
-  const envRoot = process.env[ENV_VAR2];
-  if (envRoot) {
-    if (!isAbsolute(envRoot)) {
-      process.stderr.write(`Warning: ${ENV_VAR2} must be an absolute path, got: ${envRoot}
-`);
-      return null;
-    }
-    const resolved = resolve7(envRoot);
-    try {
-      const canonical = realpathSync(resolved);
-      if (existsSync6(join8(canonical, CONFIG_PATH2))) {
-        return canonical;
-      }
-      process.stderr.write(`Warning: No .story/config.json at ${canonical}
-`);
-    } catch {
-      process.stderr.write(`Warning: ${ENV_VAR2} path does not exist: ${resolved}
-`);
-    }
-    return null;
-  }
-  try {
-    const root = discoverProjectRoot();
-    return root ? realpathSync(root) : null;
-  } catch {
-    return null;
-  }
-}
-async function main() {
-  const root = tryDiscoverRoot();
-  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 in the current directory. Navigate to a project with a .story/ directory, or set CLAUDESTORY_PROJECT_ROOT."
-    }
-  );
-  if (root) {
-    registerAllTools(server, root);
-    process.stderr.write(`claudestory MCP server running (root: ${root})
-`);
-  } else {
-    server.registerTool("claudestory_status", {
-      description: "Project summary \u2014 returns error if no .story/ project found"
-    }, () => Promise.resolve({
-      content: [{ type: "text", text: "No .story/ project found. Navigate to a directory containing .story/ or set CLAUDESTORY_PROJECT_ROOT." }],
-      isError: true
-    }));
-    process.stderr.write("claudestory MCP server running (no project found \u2014 tools will report errors)\n");
-  }
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+    )
+  ));
+  server.registerTool("claudestory_phase_create", {
+    description: "Create a new phase in the roadmap. Exactly one of after or atStart is required for positioning.",
+    inputSchema: {
+      id: z9.string().describe("Phase ID \u2014 lowercase alphanumeric with hyphens (e.g. 'my-phase')"),
+      name: z9.string().describe("Phase display name"),
+      label: z9.string().describe("Phase label (e.g. 'PHASE 1')"),
+      description: z9.string().describe("Phase description"),
+      summary: z9.string().optional().describe("One-line summary for compact display"),
+      after: z9.string().optional().describe("Insert after this phase ID"),
+      atStart: z9.boolean().optional().describe("Insert at beginning of roadmap")
+    }
+  }, (args) => runMcpWriteTool(
+    pinnedRoot,
+    (root, format) => handlePhaseCreate(
+      {
+        id: args.id,
+        name: args.name,
+        label: args.label,
+        description: args.description,
+        summary: args.summary,
+        after: args.after,
+        atStart: args.atStart ?? false
+      },
+      format,
+      root
+    )
+  ));
+  server.registerTool("claudestory_selftest", {
+    description: "Integration smoke test \u2014 creates, updates, and deletes test entities to verify the full pipeline"
+  }, () => runMcpWriteTool(
+    pinnedRoot,
+    (root, format) => handleSelftest(root, format)
+  ));
+  server.registerTool("claudestory_autonomous_guide", {
+    description: "Autonomous session orchestrator. Call at every decision point during autonomous mode.",
+    inputSchema: {
+      sessionId: z9.string().uuid().nullable().describe("Session ID (null for start action)"),
+      action: z9.enum(["start", "report", "resume", "pre_compact", "cancel"]).describe("Action to perform"),
+      report: z9.object({
+        completedAction: z9.string().describe("What was completed"),
+        ticketId: z9.string().optional().describe("Ticket ID (for ticket_picked)"),
+        commitHash: z9.string().optional().describe("Git commit hash (for commit_done)"),
+        handoverContent: z9.string().optional().describe("Handover markdown content"),
+        verdict: z9.string().optional().describe("Review verdict: approve|revise|request_changes|reject"),
+        findings: z9.array(z9.object({
+          id: z9.string(),
+          severity: z9.string(),
+          category: z9.string(),
+          description: z9.string(),
+          disposition: z9.string()
+        })).optional().describe("Review findings"),
+        reviewerSessionId: z9.string().optional().describe("Codex session ID"),
+        notes: z9.string().optional().describe("Free-text notes")
+      }).optional().describe("Report data (required for report action)")
+    }
+  }, (args) => handleAutonomousGuide(pinnedRoot, args));
 }
-var ENV_VAR2, CONFIG_PATH2, version;
-var init_mcp = __esm({
-  "src/mcp/index.ts"() {
+var INFRASTRUCTURE_ERROR_CODES;
+var init_tools = __esm({
+  "src/mcp/tools.ts"() {
     "use strict";
     init_esm_shims();
-    init_project_root_discovery();
-    init_tools();
-    ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
-    CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.10";
-    main().catch((err) => {
-      process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
-`);
-      process.exit(1);
-    });
+    init_project_loader();
+    init_errors();
+    init_helpers();
+    init_types();
+    init_status();
+    init_validate();
+    init_handover();
+    init_blocker();
+    init_ticket2();
+    init_issue2();
+    init_recap();
+    init_note2();
+    init_recommend2();
+    init_snapshot2();
+    init_export();
+    init_selftest();
+    init_handover();
+    init_guide();
+    init_phase();
+    INFRASTRUCTURE_ERROR_CODES = [
+      "io_error",
+      "project_corrupt",
+      "version_mismatch"
+    ];
   }
 });
 
 // src/core/init.ts
-import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
-import { join as join9, resolve as resolve8 } from "path";
+import { mkdir as mkdir4, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { join as join10, resolve as resolve7 } from "path";
 async function initProject(root, options) {
-  const absRoot = resolve8(root);
-  const wrapDir = join9(absRoot, ".story");
+  const absRoot = resolve7(root);
+  const wrapDir = join10(absRoot, ".story");
   let exists = false;
   try {
     const s = await stat2(wrapDir);
@@ -4768,10 +6598,10 @@ async function initProject(root, options) {
       ".story/ already exists. Use --force to overwrite config and roadmap."
     );
   }
-  await mkdir4(join9(wrapDir, "tickets"), { recursive: true });
-  await mkdir4(join9(wrapDir, "issues"), { recursive: true });
-  await mkdir4(join9(wrapDir, "handovers"), { recursive: true });
-  await mkdir4(join9(wrapDir, "notes"), { recursive: true });
+  await mkdir4(join10(wrapDir, "tickets"), { recursive: true });
+  await mkdir4(join10(wrapDir, "issues"), { recursive: true });
+  await mkdir4(join10(wrapDir, "handovers"), { recursive: true });
+  await mkdir4(join10(wrapDir, "notes"), { recursive: true });
   const created = [
     ".story/config.json",
     ".story/roadmap.json",
@@ -4798,7 +6628,7 @@ async function initProject(root, options) {
   const roadmap = {
     title: options.name,
     date: today,
-    phases: [
+    phases: options.phases ?? [
       {
         id: "p0",
         label: "PHASE 0",
@@ -4810,6 +6640,8 @@ async function initProject(root, options) {
   };
   await writeConfig(config, absRoot);
   await writeRoadmap(roadmap, absRoot);
+  const gitignorePath = join10(wrapDir, ".gitignore");
+  await ensureGitignoreEntries(gitignorePath, STORY_GITIGNORE_ENTRIES);
   const warnings = [];
   if (options.force && exists) {
     try {
@@ -4828,12 +6660,158 @@ async function initProject(root, options) {
     warnings
   };
 }
+async function ensureGitignoreEntries(gitignorePath, entries) {
+  let existing = "";
+  try {
+    existing = await readFile4(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = existing.split("\n").map((l) => l.trim());
+  const missing = entries.filter((e) => !lines.includes(e));
+  if (missing.length === 0) return;
+  let content = existing;
+  if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+  content += missing.join("\n") + "\n";
+  await writeFile2(gitignorePath, content, "utf-8");
+}
+var STORY_GITIGNORE_ENTRIES;
 var init_init = __esm({
   "src/core/init.ts"() {
     "use strict";
     init_esm_shims();
     init_project_loader();
     init_errors();
+    STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/"];
+  }
+});
+
+// src/mcp/index.ts
+var mcp_exports = {};
+import { realpathSync as realpathSync2, existsSync as existsSync8 } from "fs";
+import { resolve as resolve8, join as join11, isAbsolute } from "path";
+import { z as z10 } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function tryDiscoverRoot() {
+  const envRoot = process.env[ENV_VAR2];
+  if (envRoot) {
+    if (!isAbsolute(envRoot)) {
+      process.stderr.write(`Warning: ${ENV_VAR2} must be an absolute path, got: ${envRoot}
+`);
+      return null;
+    }
+    const resolved = resolve8(envRoot);
+    try {
+      const canonical = realpathSync2(resolved);
+      if (existsSync8(join11(canonical, CONFIG_PATH2))) {
+        return canonical;
+      }
+      process.stderr.write(`Warning: No .story/config.json at ${canonical}
+`);
+    } catch {
+      process.stderr.write(`Warning: ${ENV_VAR2} path does not exist: ${resolved}
+`);
+    }
+    return null;
+  }
+  try {
+    const root = discoverProjectRoot();
+    return root ? realpathSync2(root) : null;
+  } catch {
+    return null;
+  }
+}
+function registerDegradedTools(server) {
+  const degradedStatus = server.registerTool("claudestory_status", {
+    description: "Project summary \u2014 returns guidance if no .story/ project found"
+  }, () => Promise.resolve({
+    content: [{ type: "text", text: "No .story/ project found. Use claudestory_init to create one, or navigate to a directory with .story/." }],
+    isError: true
+  }));
+  const degradedInit = server.registerTool("claudestory_init", {
+    description: "Initialize a new .story/ project in the current directory",
+    inputSchema: {
+      name: z10.string().describe("Project name"),
+      type: z10.string().optional().describe("Project type (e.g. npm, macapp, cargo, generic)"),
+      language: z10.string().optional().describe("Primary language (e.g. typescript, swift, rust)")
+    }
+  }, async (args) => {
+    let result;
+    try {
+      const projectRoot = realpathSync2(process.cwd());
+      result = await initProject(projectRoot, {
+        name: args.name,
+        type: args.type,
+        language: args.language,
+        phases: []
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: `[init_error] ${msg}` }], isError: true };
+    }
+    try {
+      degradedStatus.remove();
+      degradedInit.remove();
+      registerAllTools(server, result.root);
+    } catch (swapErr) {
+      process.stderr.write(`claudestory: tool-swap failed after init: ${swapErr instanceof Error ? swapErr.message : String(swapErr)}
+`);
+      try {
+        registerDegradedTools(server);
+      } catch {
+      }
+      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.` }] };
+    }
+    process.stderr.write(`claudestory: initialized at ${result.root}
+`);
+    const lines = [
+      `Initialized .story/ project "${args.name}" at ${result.root}`,
+      `Created: ${result.created.join(", ")}`
+    ];
+    if (result.warnings.length > 0) {
+      lines.push(`Warnings: ${result.warnings.join("; ")}`);
+    }
+    lines.push("", "All claudestory tools are now available. Use claudestory_phase_create to add phases and claudestory_ticket_create to add tickets.");
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  });
+}
+async function main() {
+  const root = tryDiscoverRoot();
+  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/."
+    }
+  );
+  if (root) {
+    registerAllTools(server, root);
+    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");
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var ENV_VAR2, CONFIG_PATH2, version;
+var init_mcp = __esm({
+  "src/mcp/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_root_discovery();
+    init_tools();
+    init_init();
+    ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
+    CONFIG_PATH2 = ".story/config.json";
+    version = "0.1.12";
+    main().catch((err) => {
+      process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    });
   }
 });
 
@@ -4864,7 +6842,7 @@ __export(run_exports, {
   runReadCommand: () => runReadCommand,
   writeOutput: () => writeOutput
 });
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 function writeOutput(text) {
   try {
     process.stdout.write(text + "\n");
@@ -4892,7 +6870,7 @@ async function runReadCommand(format, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join10(root, ".story", "handovers");
+    const handoversDir = join12(root, ".story", "handovers");
     const result = await handler({ state, warnings, root, handoversDir, format });
     writeOutput(result.output);
     let exitCode = result.exitCode ?? ExitCode.OK;
@@ -4927,7 +6905,7 @@ async function runDeleteCommand(format, force, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join10(root, ".story", "handovers");
+    const handoversDir = join12(root, ".story", "handovers");
     if (!force && hasIntegrityWarnings(warnings)) {
       writeOutput(
         formatError(
@@ -5106,8 +7084,8 @@ var init_reference = __esm({
       {
         name: "ticket update",
         description: "Update a ticket",
-        usage: "claudestory ticket update <id> [--status <s>] [--title <t>] [--phase <p>] [--order <n>] [--description <d>] [--blocked-by <ids>] [--parent-ticket <id>] [--format json|md]",
-        flags: ["--status", "--title", "--phase", "--order", "--description", "--blocked-by", "--parent-ticket"]
+        usage: "claudestory ticket update <id> [--status <s>] [--title <t>] [--type <type>] [--phase <p>] [--order <n>] [--description <d>] [--blocked-by <ids>] [--parent-ticket <id>] [--format json|md]",
+        flags: ["--status", "--title", "--type", "--phase", "--order", "--description", "--blocked-by", "--parent-ticket"]
       },
       {
         name: "ticket delete",
@@ -5129,14 +7107,14 @@ var init_reference = __esm({
       {
         name: "issue create",
         description: "Create a new issue",
-        usage: "claudestory issue create --title <t> --severity <s> --impact <i> [--components <c>] [--related-tickets <ids>] [--location <locs>] [--format json|md]",
-        flags: ["--title", "--severity", "--impact", "--components", "--related-tickets", "--location"]
+        usage: "claudestory issue create --title <t> --severity <s> --impact <i> [--components <c>] [--related-tickets <ids>] [--location <locs>] [--phase <p>] [--format json|md]",
+        flags: ["--title", "--severity", "--impact", "--components", "--related-tickets", "--location", "--phase"]
       },
       {
         name: "issue update",
         description: "Update an issue",
-        usage: "claudestory issue update <id> [--status <s>] [--title <t>] [--severity <sev>] [--impact <i>] [--resolution <r>] [--components <c>] [--related-tickets <ids>] [--location <locs>] [--format json|md]",
-        flags: ["--status", "--title", "--severity", "--impact", "--resolution", "--components", "--related-tickets", "--location"]
+        usage: "claudestory issue update <id> [--status <s>] [--title <t>] [--severity <sev>] [--impact <i>] [--resolution <r>] [--components <c>] [--related-tickets <ids>] [--location <locs>] [--order <n>] [--phase <p>] [--format json|md]",
+        flags: ["--status", "--title", "--severity", "--impact", "--resolution", "--components", "--related-tickets", "--location", "--order", "--phase"]
       },
       {
         name: "issue delete",
@@ -5281,6 +7259,11 @@ var init_reference = __esm({
         description: "Print CLI command and MCP tool reference",
         usage: "claudestory reference [--format json|md]"
       },
+      {
+        name: "selftest",
+        description: "Run integration smoke test \u2014 create/update/delete cycle across all entity types",
+        usage: "claudestory selftest [--format json|md]"
+      },
       {
         name: "setup-skill",
         description: "Install the /story skill globally for Claude Code",
@@ -5296,7 +7279,7 @@ var init_reference = __esm({
       { name: "claudestory_ticket_get", description: "Get a ticket by ID", params: ["id"] },
       { name: "claudestory_ticket_next", description: "Highest-priority unblocked ticket(s)", params: ["count?"] },
       { name: "claudestory_ticket_blocked", description: "All blocked tickets with dependencies" },
-      { name: "claudestory_issue_list", description: "List issues with optional filters", params: ["status?", "severity?"] },
+      { name: "claudestory_issue_list", description: "List issues with optional filters", params: ["status?", "severity?", "component?"] },
       { name: "claudestory_issue_get", description: "Get an issue by ID", params: ["id"] },
       { name: "claudestory_handover_list", description: "List handover filenames (newest first)" },
       { name: "claudestory_handover_latest", description: "Content of most recent handover" },
@@ -5313,9 +7296,11 @@ var init_reference = __esm({
       { name: "claudestory_note_create", description: "Create note", params: ["content", "title?", "tags?"] },
       { name: "claudestory_note_update", description: "Update note", params: ["id", "content?", "title?", "tags?", "status?"] },
       { name: "claudestory_ticket_create", description: "Create ticket", params: ["title", "type", "phase?", "description?", "blockedBy?", "parentTicket?"] },
-      { name: "claudestory_ticket_update", description: "Update ticket", params: ["id", "status?", "title?", "order?", "description?", "phase?", "parentTicket?"] },
+      { name: "claudestory_ticket_update", description: "Update ticket", params: ["id", "status?", "title?", "type?", "order?", "description?", "phase?", "parentTicket?", "blockedBy?"] },
       { name: "claudestory_issue_create", description: "Create issue", params: ["title", "severity", "impact", "components?", "relatedTickets?", "location?", "phase?"] },
-      { name: "claudestory_issue_update", description: "Update issue", params: ["id", "status?", "title?", "severity?", "impact?", "resolution?", "components?", "relatedTickets?", "location?"] }
+      { name: "claudestory_issue_update", description: "Update issue", params: ["id", "status?", "title?", "severity?", "impact?", "resolution?", "components?", "relatedTickets?", "location?", "order?", "phase?"] },
+      { name: "claudestory_phase_create", description: "Create phase in roadmap", params: ["id", "name", "label", "description", "summary?", "after?", "atStart?"] },
+      { name: "claudestory_selftest", description: "Integration smoke test \u2014 create/update/delete cycle" }
     ];
   }
 });
@@ -5325,11 +7310,12 @@ var setup_skill_exports = {};
 __export(setup_skill_exports, {
   handleSetupSkill: () => handleSetupSkill,
   registerPreCompactHook: () => registerPreCompactHook,
+  registerStopHook: () => registerStopHook,
   resolveSkillSourceDir: () => resolveSkillSourceDir
 });
-import { mkdir as mkdir5, writeFile as writeFile2, readFile as readFile4, rm, rename as rename2, unlink as unlink3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile3, readFile as readFile5, rm, rename as rename2, unlink as unlink3 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { execFileSync } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -5338,27 +7324,27 @@ function log(msg) {
 }
 function resolveSkillSourceDir() {
   const thisDir = dirname3(fileURLToPath2(import.meta.url));
-  const bundledPath = join11(thisDir, "..", "src", "skill");
-  if (existsSync7(join11(bundledPath, "SKILL.md"))) return bundledPath;
-  const sourcePath = join11(thisDir, "..", "..", "skill");
-  if (existsSync7(join11(sourcePath, "SKILL.md"))) return sourcePath;
+  const bundledPath = join13(thisDir, "..", "src", "skill");
+  if (existsSync9(join13(bundledPath, "SKILL.md"))) return bundledPath;
+  const sourcePath = join13(thisDir, "..", "..", "skill");
+  if (existsSync9(join13(sourcePath, "SKILL.md"))) return sourcePath;
   throw new Error(
     `Cannot find bundled skill files. Checked:
   ${bundledPath}
   ${sourcePath}`
   );
 }
-function isOurHook(entry) {
+function isHookWithCommand(entry, command) {
   if (typeof entry !== "object" || entry === null) return false;
   const e = entry;
-  return e.type === "command" && typeof e.command === "string" && e.command.trim() === HOOK_COMMAND;
+  return e.type === "command" && typeof e.command === "string" && e.command.trim() === command;
 }
-async function registerPreCompactHook(settingsPath) {
-  const path2 = settingsPath ?? join11(homedir(), ".claude", "settings.json");
+async function registerHook(hookType, hookEntry, settingsPath) {
+  const path2 = settingsPath ?? join13(homedir(), ".claude", "settings.json");
   let raw = "{}";
-  if (existsSync7(path2)) {
+  if (existsSync9(path2)) {
     try {
-      raw = await readFile4(path2, "utf-8");
+      raw = await readFile5(path2, "utf-8");
     } catch {
       process.stderr.write(`Could not read ${path2} \u2014 skipping hook registration.
 `);
@@ -5389,43 +7375,45 @@ async function registerPreCompactHook(settingsPath) {
     settings.hooks = {};
   }
   const hooks = settings.hooks;
-  if ("PreCompact" in hooks) {
-    if (!Array.isArray(hooks.PreCompact)) {
-      process.stderr.write(`${path2} has unexpected hooks.PreCompact format \u2014 skipping hook registration.
+  if (hookType in hooks) {
+    if (!Array.isArray(hooks[hookType])) {
+      process.stderr.write(`${path2} has unexpected hooks.${hookType} format \u2014 skipping hook registration.
 `);
       return "skipped";
     }
   } else {
-    hooks.PreCompact = [];
-  }
-  const preCompact = hooks.PreCompact;
-  for (const group of preCompact) {
-    if (typeof group !== "object" || group === null) continue;
-    const g = group;
-    if (!Array.isArray(g.hooks)) continue;
-    for (const entry of g.hooks) {
-      if (isOurHook(entry)) return "exists";
+    hooks[hookType] = [];
+  }
+  const hookArray = hooks[hookType];
+  const hookCommand = hookEntry.command;
+  if (hookCommand) {
+    for (const group of hookArray) {
+      if (typeof group !== "object" || group === null) continue;
+      const g = group;
+      if (!Array.isArray(g.hooks)) continue;
+      for (const entry of g.hooks) {
+        if (isHookWithCommand(entry, hookCommand)) return "exists";
+      }
     }
   }
-  const ourEntry = { type: "command", command: HOOK_COMMAND };
   let appended = false;
-  for (const group of preCompact) {
+  for (const group of hookArray) {
     if (typeof group !== "object" || group === null) continue;
     const g = group;
     if (g.matcher === "" && Array.isArray(g.hooks)) {
-      g.hooks.push(ourEntry);
+      g.hooks.push(hookEntry);
       appended = true;
       break;
     }
   }
   if (!appended) {
-    preCompact.push({ matcher: "", hooks: [ourEntry] });
+    hookArray.push({ matcher: "", hooks: [hookEntry] });
   }
   const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
     const dir = dirname3(path2);
     await mkdir5(dir, { recursive: true });
-    await writeFile2(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    await writeFile3(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
     await rename2(tmpPath, path2);
   } catch (err) {
     try {
@@ -5439,9 +7427,15 @@ async function registerPreCompactHook(settingsPath) {
   }
   return "registered";
 }
+async function registerPreCompactHook(settingsPath) {
+  return registerHook("PreCompact", { type: "command", command: PRECOMPACT_HOOK_COMMAND }, settingsPath);
+}
+async function registerStopHook(settingsPath) {
+  return registerHook("Stop", { type: "command", command: STOP_HOOK_COMMAND, async: true }, settingsPath);
+}
 async function handleSetupSkill(options = {}) {
   const { skipHooks = false } = options;
-  const skillDir = join11(homedir(), ".claude", "skills", "story");
+  const skillDir = join13(homedir(), ".claude", "skills", "story");
   await mkdir5(skillDir, { recursive: true });
   let srcSkillDir;
   try {
@@ -5454,19 +7448,19 @@ async function handleSetupSkill(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const oldPrimeDir = join11(homedir(), ".claude", "skills", "prime");
-  if (existsSync7(oldPrimeDir)) {
+  const oldPrimeDir = join13(homedir(), ".claude", "skills", "prime");
+  if (existsSync9(oldPrimeDir)) {
     await rm(oldPrimeDir, { recursive: true, force: true });
     log("Removed old /prime skill (migrated to /story)");
   }
-  const existed = existsSync7(join11(skillDir, "SKILL.md"));
-  const skillContent = await readFile4(join11(srcSkillDir, "SKILL.md"), "utf-8");
-  await writeFile2(join11(skillDir, "SKILL.md"), skillContent, "utf-8");
+  const existed = existsSync9(join13(skillDir, "SKILL.md"));
+  const skillContent = await readFile5(join13(srcSkillDir, "SKILL.md"), "utf-8");
+  await writeFile3(join13(skillDir, "SKILL.md"), skillContent, "utf-8");
   let referenceWritten = false;
-  const refSrcPath = join11(srcSkillDir, "reference.md");
-  if (existsSync7(refSrcPath)) {
-    const refContent = await readFile4(refSrcPath, "utf-8");
-    await writeFile2(join11(skillDir, "reference.md"), refContent, "utf-8");
+  const refSrcPath = join13(srcSkillDir, "reference.md");
+  if (existsSync9(refSrcPath)) {
+    const refContent = await readFile5(refSrcPath, "utf-8");
+    await writeFile3(join13(skillDir, "reference.md"), refContent, "utf-8");
     referenceWritten = true;
   }
   log(`${existed ? "Updated" : "Installed"} /story skill at ${skillDir}/`);
@@ -5530,6 +7524,21 @@ async function handleSetupSkill(options = {}) {
   } else if (skipHooks) {
     log("  Hook registration skipped (--skip-hooks)");
   }
+  if (cliInPath && !skipHooks) {
+    const stopResult = await registerStopHook();
+    switch (stopResult) {
+      case "registered":
+        log("  Stop hook registered \u2014 status.json updated after every Claude response");
+        break;
+      case "exists":
+        log("  Stop hook already configured");
+        break;
+      case "skipped":
+        break;
+    }
+  } else if (!cliInPath) {
+  } else if (skipHooks) {
+  }
   log("");
   if (mcpRegistered) {
     log("Done! Restart Claude Code, then type /story in any project.");
@@ -5537,12 +7546,142 @@ async function handleSetupSkill(options = {}) {
     log("Skill installed. After registering MCP, restart Claude Code and type /story.");
   }
 }
-var HOOK_COMMAND;
+var PRECOMPACT_HOOK_COMMAND, STOP_HOOK_COMMAND;
 var init_setup_skill = __esm({
   "src/cli/commands/setup-skill.ts"() {
     "use strict";
     init_esm_shims();
-    HOOK_COMMAND = "claudestory snapshot --quiet";
+    PRECOMPACT_HOOK_COMMAND = "claudestory snapshot --quiet";
+    STOP_HOOK_COMMAND = "claudestory hook-status";
+  }
+});
+
+// src/cli/commands/hook-status.ts
+var hook_status_exports = {};
+__export(hook_status_exports, {
+  handleHookStatus: () => handleHookStatus
+});
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join14 } from "path";
+async function readStdinSilent() {
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(
+      chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(c))
+    ).toString("utf-8");
+  } catch {
+    return null;
+  }
+}
+function atomicWriteSync(targetPath, content) {
+  const tmp = `${targetPath}.${process.pid}.tmp`;
+  try {
+    writeFileSync3(tmp, content, "utf-8");
+    renameSync2(tmp, targetPath);
+    return true;
+  } catch {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+    return false;
+  }
+}
+function inactivePayload() {
+  return { schemaVersion: CURRENT_STATUS_SCHEMA_VERSION, sessionActive: false, source: "hook" };
+}
+function activePayload(session) {
+  return {
+    schemaVersion: CURRENT_STATUS_SCHEMA_VERSION,
+    sessionActive: true,
+    sessionId: session.sessionId,
+    state: session.state,
+    ticket: session.ticket?.id ?? null,
+    ticketTitle: session.ticket?.title ?? null,
+    risk: session.ticket?.risk ?? null,
+    claudeStatus: deriveClaudeStatus(session.state, session.waitingForRetry),
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastGuideCall: session.lastGuideCall ?? null,
+    completedThisSession: session.completedTickets?.map((t) => t.id) ?? [],
+    contextPressure: session.contextPressure?.level ?? "unknown",
+    branch: session.git?.branch ?? null,
+    source: "hook"
+  };
+}
+function ensureGitignore(root) {
+  const gitignorePath = join14(root, ".story", ".gitignore");
+  let existing = "";
+  try {
+    existing = readFileSync3(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = existing.split("\n").map((l) => l.trim());
+  const missing = STORY_GITIGNORE_ENTRIES.filter((e) => !lines.includes(e));
+  if (missing.length === 0) return;
+  let content = existing;
+  if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+  content += missing.join("\n") + "\n";
+  try {
+    writeFileSync3(gitignorePath, content, "utf-8");
+  } catch {
+  }
+}
+function writeStatus(root, payload) {
+  ensureGitignore(root);
+  const statusPath = join14(root, ".story", "status.json");
+  const content = JSON.stringify(payload, null, 2) + "\n";
+  atomicWriteSync(statusPath, content);
+}
+async function handleHookStatus() {
+  try {
+    if (process.stdin.isTTY) {
+      const root2 = discoverProjectRoot();
+      if (root2) {
+        const session2 = findActiveSessionMinimal(root2);
+        const payload2 = session2 ? activePayload(session2) : inactivePayload();
+        writeStatus(root2, payload2);
+      }
+      process.exit(0);
+    }
+    const raw = await readStdinSilent();
+    if (raw === null || raw === "") {
+      process.exit(0);
+    }
+    let input;
+    try {
+      input = JSON.parse(raw);
+    } catch {
+      process.exit(0);
+    }
+    if (input.stop_hook_active === true) {
+      process.exit(0);
+    }
+    const cwd = input.cwd;
+    if (typeof cwd !== "string" || !cwd) {
+      process.exit(0);
+    }
+    const root = discoverProjectRoot(cwd);
+    if (!root) {
+      process.exit(0);
+    }
+    const session = findActiveSessionMinimal(root);
+    const payload = session ? activePayload(session) : inactivePayload();
+    writeStatus(root, payload);
+  } catch {
+  }
+  process.exit(0);
+}
+var init_hook_status = __esm({
+  "src/cli/commands/hook-status.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_root_discovery();
+    init_init();
+    init_session_types();
+    init_session();
   }
 });
 
@@ -5552,6 +7691,7 @@ __export(register_exports, {
   registerBlockerCommand: () => registerBlockerCommand,
   registerExportCommand: () => registerExportCommand,
   registerHandoverCommand: () => registerHandoverCommand,
+  registerHookStatusCommand: () => registerHookStatusCommand,
   registerInitCommand: () => registerInitCommand,
   registerIssueCommand: () => registerIssueCommand,
   registerNoteCommand: () => registerNoteCommand,
@@ -5559,6 +7699,7 @@ __export(register_exports, {
   registerRecapCommand: () => registerRecapCommand,
   registerRecommendCommand: () => registerRecommendCommand,
   registerReferenceCommand: () => registerReferenceCommand,
+  registerSelftestCommand: () => registerSelftestCommand,
   registerSetupSkillCommand: () => registerSetupSkillCommand,
   registerSnapshotCommand: () => registerSnapshotCommand,
   registerStatusCommand: () => registerStatusCommand,
@@ -6007,6 +8148,9 @@ function registerTicketCommand(yargs) {
         }).option("title", {
           type: "string",
           describe: "New title"
+        }).option("type", {
+          type: "string",
+          describe: "New type"
         }).option("phase", {
           type: "string",
           describe: "New phase ID"
@@ -6053,6 +8197,7 @@ function registerTicketCommand(yargs) {
             {
               status: argv.status,
               title: argv.title,
+              type: argv.type,
               phase: argv.phase === "" ? null : argv.phase,
               order: argv.order,
               description,
@@ -6234,7 +8379,7 @@ function registerIssueCommand(yargs) {
               location: normalizeArrayOption(
                 argv.location
               ),
-              phase: argv.phase
+              phase: argv.phase === "" ? void 0 : argv.phase
             },
             format,
             root
@@ -6296,6 +8441,12 @@ function registerIssueCommand(yargs) {
           type: "string",
           array: true,
           describe: "File locations"
+        }).option("order", {
+          type: "number",
+          describe: "New sort order"
+        }).option("phase", {
+          type: "string",
+          describe: "New phase ID"
         }).conflicts("impact", "stdin")
       ),
       async (argv) => {
@@ -6328,7 +8479,9 @@ function registerIssueCommand(yargs) {
               resolution: argv.resolution === "" ? null : argv.resolution,
               components: argv.components ? normalizeArrayOption(argv.components) : void 0,
               relatedTickets: argv["related-tickets"] ? normalizeArrayOption(argv["related-tickets"]) : void 0,
-              location: argv.location ? normalizeArrayOption(argv.location) : void 0
+              location: argv.location ? normalizeArrayOption(argv.location) : void 0,
+              order: argv.order,
+              phase: argv.phase === "" ? null : argv.phase
             },
             format,
             root
@@ -6921,7 +9074,6 @@ function registerNoteCommand(yargs) {
           describe: "New tags (replaces existing)"
         }).option("clear-tags", {
           type: "boolean",
-          default: false,
           describe: "Clear all tags"
         }).option("status", {
           type: "string",
@@ -7037,6 +9189,44 @@ function registerRecommendCommand(yargs) {
     }
   );
 }
+function registerSelftestCommand(yargs) {
+  return yargs.command(
+    "selftest",
+    "Run integration smoke test \u2014 create/update/delete cycle across all entity types",
+    (y) => addFormatOption(y),
+    async (argv) => {
+      const format = parseOutputFormat(argv.format);
+      const root = (await Promise.resolve().then(() => (init_project_root_discovery(), project_root_discovery_exports))).discoverProjectRoot();
+      if (!root) {
+        writeOutput(
+          formatError("not_found", "No .story/ project found.", format)
+        );
+        process.exitCode = ExitCode.USER_ERROR;
+        return;
+      }
+      try {
+        const result = await handleSelftest(root, format);
+        writeOutput(result.output);
+        process.exitCode = result.exitCode ?? ExitCode.OK;
+      } catch (err) {
+        if (err instanceof CliValidationError) {
+          writeOutput(formatError(err.code, err.message, format));
+          process.exitCode = ExitCode.USER_ERROR;
+          return;
+        }
+        const { ProjectLoaderError: ProjectLoaderError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+        if (err instanceof ProjectLoaderError2) {
+          writeOutput(formatError(err.code, err.message, format));
+          process.exitCode = ExitCode.USER_ERROR;
+          return;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        writeOutput(formatError("io_error", message, format));
+        process.exitCode = ExitCode.USER_ERROR;
+      }
+    }
+  );
+}
 function registerSetupSkillCommand(yargs) {
   return yargs.command(
     "setup-skill",
@@ -7044,7 +9234,7 @@ function registerSetupSkillCommand(yargs) {
     (y) => y.option("skip-hooks", {
       type: "boolean",
       default: false,
-      description: "Skip PreCompact hook registration"
+      description: "Skip hook registration (PreCompact + Stop)"
     }),
     async (argv) => {
       const { handleSetupSkill: handleSetupSkill2 } = await Promise.resolve().then(() => (init_setup_skill(), setup_skill_exports));
@@ -7052,6 +9242,18 @@ function registerSetupSkillCommand(yargs) {
     }
   );
 }
+function registerHookStatusCommand(yargs) {
+  return yargs.command(
+    "hook-status",
+    false,
+    // hidden — machine-facing, not shown in --help
+    (y) => y,
+    async () => {
+      const { handleHookStatus: handleHookStatus2 } = await Promise.resolve().then(() => (init_hook_status(), hook_status_exports));
+      await handleHookStatus2();
+    }
+  );
+}
 var init_register = __esm({
   "src/cli/register.ts"() {
     "use strict";
@@ -7073,6 +9275,7 @@ var init_register = __esm({
     init_export();
     init_snapshot2();
     init_reference();
+    init_selftest();
   }
 });
 
@@ -7103,9 +9306,11 @@ async function runCli() {
     registerNoteCommand: registerNoteCommand2,
     registerRecommendCommand: registerRecommendCommand2,
     registerReferenceCommand: registerReferenceCommand2,
-    registerSetupSkillCommand: registerSetupSkillCommand2
+    registerSelftestCommand: registerSelftestCommand2,
+    registerSetupSkillCommand: registerSetupSkillCommand2,
+    registerHookStatusCommand: registerHookStatusCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.10";
+  const version2 = "0.1.12";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");
@@ -7141,7 +9346,9 @@ async function runCli() {
   cli = registerExportCommand2(cli);
   cli = registerRecommendCommand2(cli);
   cli = registerReferenceCommand2(cli);
+  cli = registerSelftestCommand2(cli);
   cli = registerSetupSkillCommand2(cli);
+  cli = registerHookStatusCommand2(cli);
   function handleUnexpectedError(err) {
     if (err instanceof HandledError) return;
     const message = err instanceof Error ? err.message : String(err);