@anthropologies/claudestory 0.1.11 → 0.1.12

package/dist/cli.js

@@ -261,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();
   }
 });
@@ -2772,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);
@@ -3363,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";
@@ -4341,8 +4350,1506 @@ var init_selftest = __esm({
   }
 });
 
+// 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"]
+    }
+  };
+  writeSessionSync(dir, state);
+  return state;
+}
+function readSession(dir) {
+  const path2 = statePath(dir);
+  let raw;
+  try {
+    raw = readFileSync(path2, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const result = SessionStateSchema.safeParse(parsed);
+  if (!result.success) return null;
+  return result.data;
+}
+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 updated;
+}
+function appendEvent(dir, event) {
+  try {
+    const path2 = eventsPath(dir);
+    const line = JSON.stringify(event) + "\n";
+    writeFileSync(path2, line, { flag: "a", encoding: "utf-8" });
+  } catch {
+  }
+}
+function deleteSession(root, sessionId) {
+  const dir = sessionDir(root, sessionId);
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+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
+    }
+  };
+}
+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 join6, resolve as resolve6 } from "path";
+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`);
@@ -4531,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 {
@@ -4577,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)) {
@@ -4649,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,
@@ -4664,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,
@@ -4679,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);
@@ -4695,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) {
@@ -4718,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,
@@ -4735,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", {
@@ -4750,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,
@@ -4762,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) {
@@ -4785,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()) {
@@ -4803,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,
@@ -4828,15 +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"),
-      type: z8.enum(TICKET_TYPES).optional().describe("New type: task, feature, chore"),
-      order: z8.number().int().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,
@@ -4859,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,
@@ -4886,17 +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"),
-      order: z8.number().int().optional().describe("New sort order"),
-      phase: z8.string().nullable().optional().describe("New phase ID (null to clear)")
+      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,
@@ -4921,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,
@@ -4931,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,
@@ -4956,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,
@@ -4980,13 +6487,13 @@ function registerAllTools(server, pinnedRoot) {
   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: z8.string().describe("Phase ID \u2014 lowercase alphanumeric with hyphens (e.g. 'my-phase')"),
-      name: z8.string().describe("Phase display name"),
-      label: z8.string().describe("Phase label (e.g. 'PHASE 1')"),
-      description: z8.string().describe("Phase description"),
-      summary: z8.string().optional().describe("One-line summary for compact display"),
-      after: z8.string().optional().describe("Insert after this phase ID"),
-      atStart: z8.boolean().optional().describe("Insert at beginning of roadmap")
+      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,
@@ -5010,6 +6517,29 @@ function registerAllTools(server, pinnedRoot) {
     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 INFRASTRUCTURE_ERROR_CODES;
 var init_tools = __esm({
@@ -5033,6 +6563,7 @@ var init_tools = __esm({
     init_export();
     init_selftest();
     init_handover();
+    init_guide();
     init_phase();
     INFRASTRUCTURE_ERROR_CODES = [
       "io_error",
@@ -5043,11 +6574,11 @@ var init_tools = __esm({
 });
 
 // src/core/init.ts
-import { mkdir as mkdir4, stat as stat2 } from "fs/promises";
-import { join as join8, resolve as resolve7 } 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 = resolve7(root);
-  const wrapDir = join8(absRoot, ".story");
+  const wrapDir = join10(absRoot, ".story");
   let exists = false;
   try {
     const s = await stat2(wrapDir);
@@ -5067,10 +6598,10 @@ async function initProject(root, options) {
       ".story/ already exists. Use --force to overwrite config and roadmap."
     );
   }
-  await mkdir4(join8(wrapDir, "tickets"), { recursive: true });
-  await mkdir4(join8(wrapDir, "issues"), { recursive: true });
-  await mkdir4(join8(wrapDir, "handovers"), { recursive: true });
-  await mkdir4(join8(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",
@@ -5109,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 {
@@ -5127,20 +6660,36 @@ 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, existsSync as existsSync6 } from "fs";
-import { resolve as resolve8, join as join9, isAbsolute } from "path";
-import { z as z9 } from "zod";
+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() {
@@ -5153,8 +6702,8 @@ function tryDiscoverRoot() {
     }
     const resolved = resolve8(envRoot);
     try {
-      const canonical = realpathSync(resolved);
-      if (existsSync6(join9(canonical, CONFIG_PATH2))) {
+      const canonical = realpathSync2(resolved);
+      if (existsSync8(join11(canonical, CONFIG_PATH2))) {
         return canonical;
       }
       process.stderr.write(`Warning: No .story/config.json at ${canonical}
@@ -5167,7 +6716,7 @@ function tryDiscoverRoot() {
   }
   try {
     const root = discoverProjectRoot();
-    return root ? realpathSync(root) : null;
+    return root ? realpathSync2(root) : null;
   } catch {
     return null;
   }
@@ -5182,14 +6731,14 @@ function registerDegradedTools(server) {
   const degradedInit = server.registerTool("claudestory_init", {
     description: "Initialize a new .story/ project in the current directory",
     inputSchema: {
-      name: z9.string().describe("Project name"),
-      type: z9.string().optional().describe("Project type (e.g. npm, macapp, cargo, generic)"),
-      language: z9.string().optional().describe("Primary language (e.g. typescript, swift, rust)")
+      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 = realpathSync(process.cwd());
+      const projectRoot = realpathSync2(process.cwd());
       result = await initProject(projectRoot, {
         name: args.name,
         type: args.type,
@@ -5257,7 +6806,7 @@ var init_mcp = __esm({
     init_init();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.10";
+    version = "0.1.12";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -5293,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");
@@ -5321,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;
@@ -5356,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(
@@ -5761,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";
@@ -5774,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.
 `);
@@ -5825,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 = [];
+    hooks[hookType] = [];
   }
-  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";
+  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 {
@@ -5875,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 {
@@ -5890,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}/`);
@@ -5966,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.");
@@ -5973,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();
   }
 });
 
@@ -5988,6 +7691,7 @@ __export(register_exports, {
   registerBlockerCommand: () => registerBlockerCommand,
   registerExportCommand: () => registerExportCommand,
   registerHandoverCommand: () => registerHandoverCommand,
+  registerHookStatusCommand: () => registerHookStatusCommand,
   registerInitCommand: () => registerInitCommand,
   registerIssueCommand: () => registerIssueCommand,
   registerNoteCommand: () => registerNoteCommand,
@@ -7530,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));
@@ -7538,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";
@@ -7591,9 +9307,10 @@ async function runCli() {
     registerRecommendCommand: registerRecommendCommand2,
     registerReferenceCommand: registerReferenceCommand2,
     registerSelftestCommand: registerSelftestCommand2,
-    registerSetupSkillCommand: registerSetupSkillCommand2
+    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");
@@ -7631,6 +9348,7 @@ async function runCli() {
   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);