@anthropologies/claudestory 0.1.14 → 0.1.16

package/dist/cli.js

@@ -562,6 +562,29 @@ var init_handover_parser = __esm({
 });
 
 // src/core/project-loader.ts
+var project_loader_exports = {};
+__export(project_loader_exports, {
+  atomicWrite: () => atomicWrite,
+  deleteIssue: () => deleteIssue,
+  deleteNote: () => deleteNote,
+  deleteTicket: () => deleteTicket,
+  guardPath: () => guardPath,
+  loadProject: () => loadProject,
+  runTransaction: () => runTransaction,
+  runTransactionUnlocked: () => runTransactionUnlocked,
+  serializeJSON: () => serializeJSON,
+  sortKeysDeep: () => sortKeysDeep,
+  withProjectLock: () => withProjectLock,
+  writeConfig: () => writeConfig,
+  writeIssue: () => writeIssue,
+  writeIssueUnlocked: () => writeIssueUnlocked,
+  writeNote: () => writeNote,
+  writeNoteUnlocked: () => writeNoteUnlocked,
+  writeRoadmap: () => writeRoadmap,
+  writeRoadmapUnlocked: () => writeRoadmapUnlocked,
+  writeTicket: () => writeTicket,
+  writeTicketUnlocked: () => writeTicketUnlocked
+});
 import {
   readdir as readdir2,
   readFile as readFile2,
@@ -920,6 +943,12 @@ async function runTransactionUnlocked(root, operations) {
     throw new ProjectLoaderError("io_error", "Transaction failed", err);
   }
 }
+async function runTransaction(root, operations) {
+  const wrapDir = resolve2(root, ".story");
+  await withLock(wrapDir, async () => {
+    await runTransactionUnlocked(root, operations);
+  });
+}
 async function doRecoverTransaction(wrapDir) {
   const journalPath = join3(wrapDir, ".txn.json");
   let entries;
@@ -5237,6 +5266,19 @@ async function handleReportPlan(root, dir, state, report) {
     });
   }
   const risk = assessRisk(void 0, void 0);
+  if (state.ticket) {
+    try {
+      const { withProjectLock: withProjectLock2, writeTicketUnlocked: writeTicketUnlocked2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
+      await withProjectLock2(root, { strict: false }, async ({ state: projectState }) => {
+        const ticket = projectState.ticketByID(state.ticket.id);
+        if (ticket && ticket.status !== "inprogress") {
+          const updated = { ...ticket, status: "inprogress" };
+          await writeTicketUnlocked2(updated, root);
+        }
+      });
+    } catch {
+    }
+  }
   const written = writeSessionSync(dir, {
     ...state,
     state: "PLAN_REVIEW",
@@ -5594,11 +5636,11 @@ async function handleReportComplete(root, dir, state, report) {
   const maxTickets = updated.config.maxTicketsPerSession;
   let nextState;
   let advice = "ok";
-  if (pressure === "critical") {
+  if (maxTickets > 0 && ticketsDone >= maxTickets) {
     nextState = "HANDOVER";
-    advice = "compact-now";
-  } else if (maxTickets > 0 && ticketsDone >= maxTickets) {
+  } else if (pressure === "critical") {
     nextState = "HANDOVER";
+    advice = "compact-now";
   } else if (pressure === "high") {
     advice = "consider-compact";
     nextState = "PICK_TICKET";
@@ -5678,6 +5720,36 @@ async function handleReportHandover(root, dir, state, report) {
     } catch {
     }
   }
+  const pressureLevel = state.contextPressure?.level ?? "low";
+  const maxTickets = state.config.maxTicketsPerSession;
+  const capReached = maxTickets > 0 && state.completedTickets.length >= maxTickets;
+  let hasMoreTickets = false;
+  try {
+    const { state: ps } = await loadProject(root);
+    hasMoreTickets = nextTickets(ps, 1).kind === "found";
+  } catch {
+  }
+  if (pressureLevel === "critical" && hasMoreTickets && !capReached) {
+    return guideResult(state, "HANDOVER", {
+      instruction: [
+        "# Context Compaction Needed",
+        "",
+        `${state.completedTickets.length} ticket(s) completed so far. Handover written. Context is large \u2014 time to compact and continue.`,
+        "",
+        'Call `claudestory_autonomous_guide` with `action: "pre_compact"` now:',
+        "```json",
+        `{ "sessionId": "${state.sessionId}", "action": "pre_compact" }`,
+        "```",
+        "",
+        'After pre_compact responds, run `/compact`, then call with `action: "resume"` to continue working on more tickets.'
+      ].join("\n"),
+      reminders: [
+        "Do NOT stop. This is a context compaction, not a session end.",
+        "Call pre_compact \u2192 /compact \u2192 resume to continue autonomous work."
+      ],
+      contextAdvice: "compact-now"
+    });
+  }
   const written = writeSessionSync(dir, {
     ...state,
     state: "SESSION_END",
@@ -5725,6 +5797,40 @@ async function handleResume(root, args) {
     resumeFromRevision: null,
     contextPressure: { ...info.state.contextPressure, compactionCount: (info.state.contextPressure?.compactionCount ?? 0) + 1 }
   });
+  if (resumeState === "PICK_TICKET") {
+    let candidatesText = "No ticket candidates available.";
+    let topCandidate = null;
+    try {
+      const { state: ps } = await loadProject(root);
+      const result = nextTickets(ps, 5);
+      if (result.kind === "found") {
+        topCandidate = result.candidates[0] ?? null;
+        candidatesText = result.candidates.map(
+          (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type})`
+        ).join("\n");
+      }
+    } catch {
+    }
+    return guideResult(written, "PICK_TICKET", {
+      instruction: [
+        "# Resumed After Compact \u2014 Continue Working",
+        "",
+        `${written.completedTickets.length} ticket(s) done so far. Context compacted. Pick the next ticket immediately.`,
+        "",
+        candidatesText,
+        "",
+        topCandidate ? `Pick **${topCandidate.ticket.id}** by calling \`claudestory_autonomous_guide\` now:` : "Pick a ticket now:",
+        "```json",
+        topCandidate ? `{ "sessionId": "${written.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "${topCandidate.ticket.id}" } }` : `{ "sessionId": "${written.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "T-XXX" } }`,
+        "```"
+      ].join("\n"),
+      reminders: [
+        "Do NOT stop or summarize. Pick the next ticket IMMEDIATELY.",
+        "Do NOT ask the user for confirmation.",
+        "You are in autonomous mode \u2014 continue working."
+      ]
+    });
+  }
   return guideResult(written, resumeState, {
     instruction: [
       "# Resumed After Compact",
@@ -5736,6 +5842,7 @@ async function handleResume(root, args) {
     ].join("\n"),
     reminders: [
       "Do NOT use plan mode.",
+      "Do NOT stop or summarize.",
       "Call autonomous_guide after completing each step."
     ]
   });
@@ -5751,11 +5858,12 @@ async function handlePreCompact(root, args) {
     return guideError(new Error(`Session ${args.sessionId} is already in COMPACT state. Call action: "resume" to continue.`));
   }
   const headResult = await gitHead(root);
+  const resumeTarget = info.state.state === "HANDOVER" ? "PICK_TICKET" : info.state.state;
   const written = writeSessionSync(info.dir, {
     ...refreshLease(info.state),
     state: "COMPACT",
     previousState: info.state.state,
-    preCompactState: info.state.state,
+    preCompactState: resumeTarget,
     resumeFromRevision: info.state.revision,
     git: {
       ...info.state.git,
@@ -6835,7 +6943,7 @@ var init_mcp = __esm({
     init_init();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.14";
+    version = "0.1.16";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -7714,10 +7822,95 @@ var init_hook_status = __esm({
   }
 });
 
+// src/cli/commands/config-update.ts
+var config_update_exports = {};
+__export(config_update_exports, {
+  handleConfigSetOverrides: () => handleConfigSetOverrides
+});
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join15 } from "path";
+async function handleConfigSetOverrides(root, format, options) {
+  const { json: jsonArg, clear } = options;
+  if (!clear && !jsonArg) {
+    return {
+      output: format === "json" ? JSON.stringify({ version: 1, error: "Provide --json or --clear" }) : "Error: Provide --json or --clear",
+      errorCode: "invalid_input"
+    };
+  }
+  let parsedOverrides = {};
+  if (jsonArg) {
+    try {
+      parsedOverrides = JSON.parse(jsonArg);
+      if (typeof parsedOverrides !== "object" || parsedOverrides === null || Array.isArray(parsedOverrides)) {
+        return {
+          output: format === "json" ? JSON.stringify({ version: 1, error: "Invalid JSON: expected an object" }) : "Error: Invalid JSON: expected an object",
+          errorCode: "invalid_input"
+        };
+      }
+    } catch {
+      return {
+        output: format === "json" ? JSON.stringify({ version: 1, error: "Invalid JSON syntax" }) : "Error: Invalid JSON syntax",
+        errorCode: "invalid_input"
+      };
+    }
+  }
+  let resultOverrides = null;
+  await withProjectLock(root, { strict: false }, async () => {
+    const configPath = join15(root, ".story", "config.json");
+    const rawContent = readFileSync4(configPath, "utf-8");
+    const raw = JSON.parse(rawContent);
+    if (clear) {
+      delete raw.recipeOverrides;
+    } else {
+      const existing = raw.recipeOverrides ?? {};
+      const merged = { ...existing, ...parsedOverrides };
+      for (const [k, v] of Object.entries(merged)) {
+        if (v === null) delete merged[k];
+      }
+      if (Object.keys(merged).length === 0) {
+        delete raw.recipeOverrides;
+      } else {
+        raw.recipeOverrides = merged;
+      }
+    }
+    const validated = ConfigSchema.safeParse(raw);
+    if (!validated.success) {
+      const message = validated.error.issues.map((i) => i.message).join("; ");
+      throw new ProjectLoaderError(
+        "invalid_input",
+        `Invalid config after merge: ${message}`
+      );
+    }
+    await guardPath(configPath, root);
+    await atomicWrite(configPath, JSON.stringify(raw, null, 2) + "\n");
+    resultOverrides = raw.recipeOverrides ?? null;
+  });
+  const data = { recipeOverrides: resultOverrides };
+  if (format === "json") {
+    return { output: JSON.stringify({ version: 1, data }, null, 2) };
+  }
+  if (resultOverrides === null) {
+    return { output: "Recipe overrides cleared (using recipe defaults)." };
+  }
+  const lines = Object.entries(resultOverrides).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`);
+  return { output: `Recipe overrides updated:
+${lines.join("\n")}` };
+}
+var init_config_update = __esm({
+  "src/cli/commands/config-update.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_loader();
+    init_config();
+    init_errors();
+  }
+});
+
 // src/cli/register.ts
 var register_exports = {};
 __export(register_exports, {
   registerBlockerCommand: () => registerBlockerCommand,
+  registerConfigCommand: () => registerConfigCommand,
   registerExportCommand: () => registerExportCommand,
   registerHandoverCommand: () => registerHandoverCommand,
   registerHookStatusCommand: () => registerHookStatusCommand,
@@ -9283,6 +9476,51 @@ function registerHookStatusCommand(yargs) {
     }
   );
 }
+function registerConfigCommand(yargs) {
+  return yargs.command(
+    "config",
+    "Manage project configuration",
+    (y) => y.command(
+      "set-overrides",
+      "Set or clear recipe overrides in config.json",
+      (y2) => y2.option("json", {
+        type: "string",
+        describe: "JSON object to merge into recipeOverrides"
+      }).option("clear", {
+        type: "boolean",
+        describe: "Remove recipeOverrides entirely (reset to defaults)"
+      }).option("format", {
+        choices: ["json", "md"],
+        default: "md",
+        describe: "Output format"
+      }),
+      async (argv) => {
+        const { handleConfigSetOverrides: handleConfigSetOverrides2 } = await Promise.resolve().then(() => (init_config_update(), config_update_exports));
+        const { writeOutput: writeOutput2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+        const format = argv.format;
+        try {
+          const result = await handleConfigSetOverrides2(
+            process.cwd(),
+            format,
+            { json: argv.json, clear: argv.clear === true }
+          );
+          writeOutput2(result.output);
+          if (result.errorCode) process.exitCode = 1;
+        } catch (err) {
+          const { formatError: formatError2, ExitCode: ExitCode2 } = await Promise.resolve().then(() => (init_output_formatter(), output_formatter_exports));
+          const { ProjectLoaderError: ProjectLoaderError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+          if (err instanceof ProjectLoaderError2) {
+            writeOutput2(formatError2(err.code, err.message, format));
+          } else {
+            const message = err instanceof Error ? err.message : String(err);
+            writeOutput2(formatError2("io_error", message, format));
+          }
+          process.exitCode = ExitCode2.USER_ERROR;
+        }
+      }
+    ).demandCommand(1, "Specify a config subcommand. Available: set-overrides")
+  );
+}
 var init_register = __esm({
   "src/cli/register.ts"() {
     "use strict";
@@ -9337,9 +9575,10 @@ async function runCli() {
     registerReferenceCommand: registerReferenceCommand2,
     registerSelftestCommand: registerSelftestCommand2,
     registerSetupSkillCommand: registerSetupSkillCommand2,
-    registerHookStatusCommand: registerHookStatusCommand2
+    registerHookStatusCommand: registerHookStatusCommand2,
+    registerConfigCommand: registerConfigCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.14";
+  const version2 = "0.1.16";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");
@@ -9378,6 +9617,7 @@ async function runCli() {
   cli = registerSelftestCommand2(cli);
   cli = registerSetupSkillCommand2(cli);
   cli = registerHookStatusCommand2(cli);
+  cli = registerConfigCommand2(cli);
   function handleUnexpectedError(err) {
     if (err instanceof HandledError) return;
     const message = err instanceof Error ? err.message : String(err);

package/dist/index.d.ts

@@ -1237,15 +1237,40 @@ declare const SnapshotV1Schema: z.ZodObject<{
         file: z.ZodString;
         message: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }, {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
+    version: 1;
+    config: {
+        version: number;
+        type: string;
+        language: string;
+        project: string;
+        features: {
+            issues: boolean;
+            tickets: boolean;
+            handovers: boolean;
+            roadmap: boolean;
+            reviews: boolean;
+        } & {
+            [k: string]: unknown;
+        };
+        schemaVersion?: number | undefined;
+        recipe?: string | undefined;
+        recipeOverrides?: {
+            maxTicketsPerSession?: number | undefined;
+            compactThreshold?: string | undefined;
+            reviewBackends?: string[] | undefined;
+        } | undefined;
+    } & {
+        [k: string]: unknown;
+    };
     issues: z.objectOutputType<{
         id: z.ZodString;
         title: z.ZodString;
@@ -1281,8 +1306,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.ZodTypeAny, "passthrough">[];
     roadmap: {
-        title: string;
         date: string;
+        title: string;
         phases: z.objectOutputType<{
             id: z.ZodString;
             label: z.ZodString;
@@ -1300,7 +1325,6 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    version: 1;
     project: string;
     notes: z.objectOutputType<{
         id: z.ZodString;
@@ -1312,11 +1336,19 @@ declare const SnapshotV1Schema: z.ZodObject<{
         updatedDate: z.ZodEffects<z.ZodString, string, string>;
     }, z.ZodTypeAny, "passthrough">[];
     createdAt: string;
-    config: {
+    handoverFilenames: string[];
+    warnings?: {
         type: string;
+        message: string;
+        file: string;
+    }[] | undefined;
+}, {
+    version: 1;
+    config: {
         version: number;
-        project: string;
+        type: string;
         language: string;
+        project: string;
         features: {
             issues: boolean;
             tickets: boolean;
@@ -1336,13 +1368,6 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    handoverFilenames: string[];
-    warnings?: {
-        message: string;
-        type: string;
-        file: string;
-    }[] | undefined;
-}, {
     issues: z.objectInputType<{
         id: z.ZodString;
         title: z.ZodString;
@@ -1378,8 +1403,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         lastModifiedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.ZodTypeAny, "passthrough">[];
     roadmap: {
-        title: string;
         date: string;
+        title: string;
         phases: z.objectInputType<{
             id: z.ZodString;
             label: z.ZodString;
@@ -1397,33 +1422,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    version: 1;
     project: string;
     createdAt: string;
-    config: {
-        type: string;
-        version: number;
-        project: string;
-        language: string;
-        features: {
-            issues: boolean;
-            tickets: boolean;
-            handovers: boolean;
-            roadmap: boolean;
-            reviews: boolean;
-        } & {
-            [k: string]: unknown;
-        };
-        schemaVersion?: number | undefined;
-        recipe?: string | undefined;
-        recipeOverrides?: {
-            maxTicketsPerSession?: number | undefined;
-            compactThreshold?: string | undefined;
-            reviewBackends?: string[] | undefined;
-        } | undefined;
-    } & {
-        [k: string]: unknown;
-    };
     notes?: z.objectInputType<{
         id: z.ZodString;
         title: z.ZodNullable<z.ZodString>;
@@ -1434,8 +1434,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         updatedDate: z.ZodEffects<z.ZodString, string, string>;
     }, z.ZodTypeAny, "passthrough">[] | undefined;
     warnings?: {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }[] | undefined;
     handoverFilenames?: string[] | undefined;

package/dist/mcp.js

@@ -504,6 +504,29 @@ var init_handover_parser = __esm({
 });
 
 // src/core/project-loader.ts
+var project_loader_exports = {};
+__export(project_loader_exports, {
+  atomicWrite: () => atomicWrite,
+  deleteIssue: () => deleteIssue,
+  deleteNote: () => deleteNote,
+  deleteTicket: () => deleteTicket,
+  guardPath: () => guardPath,
+  loadProject: () => loadProject,
+  runTransaction: () => runTransaction,
+  runTransactionUnlocked: () => runTransactionUnlocked,
+  serializeJSON: () => serializeJSON,
+  sortKeysDeep: () => sortKeysDeep,
+  withProjectLock: () => withProjectLock,
+  writeConfig: () => writeConfig,
+  writeIssue: () => writeIssue,
+  writeIssueUnlocked: () => writeIssueUnlocked,
+  writeNote: () => writeNote,
+  writeNoteUnlocked: () => writeNoteUnlocked,
+  writeRoadmap: () => writeRoadmap,
+  writeRoadmapUnlocked: () => writeRoadmapUnlocked,
+  writeTicket: () => writeTicket,
+  writeTicketUnlocked: () => writeTicketUnlocked
+});
 import {
   readdir as readdir2,
   readFile as readFile2,
@@ -807,6 +830,67 @@ async function withProjectLock(root, options, handler) {
     await handler(result);
   });
 }
+async function runTransactionUnlocked(root, operations) {
+  const wrapDir = resolve2(root, ".story");
+  const journalPath = join3(wrapDir, ".txn.json");
+  const entries = [];
+  let commitStarted = false;
+  try {
+    for (const op of operations) {
+      if (op.op === "write") {
+        const tempPath = `${op.target}.${process.pid}.tmp`;
+        entries.push({ op: "write", target: op.target, tempPath });
+      } else {
+        entries.push({ op: "delete", target: op.target });
+      }
+    }
+    const journal = { entries, commitStarted: false };
+    await fsyncWrite(journalPath, JSON.stringify(journal, null, 2));
+    for (const op of operations) {
+      if (op.op === "write") {
+        const tempPath = `${op.target}.${process.pid}.tmp`;
+        await fsyncWrite(tempPath, op.content);
+      }
+    }
+    journal.commitStarted = true;
+    await fsyncWrite(journalPath, JSON.stringify(journal, null, 2));
+    commitStarted = true;
+    for (const entry of entries) {
+      if (entry.op === "write" && entry.tempPath) {
+        await rename(entry.tempPath, entry.target);
+      } else if (entry.op === "delete") {
+        try {
+          await unlink(entry.target);
+        } catch {
+        }
+      }
+    }
+    await unlink(journalPath);
+  } catch (err) {
+    if (!commitStarted) {
+      for (const entry of entries) {
+        if (entry.tempPath) {
+          try {
+            await unlink(entry.tempPath);
+          } catch {
+          }
+        }
+      }
+      try {
+        await unlink(journalPath);
+      } catch {
+      }
+    }
+    if (err instanceof ProjectLoaderError) throw err;
+    throw new ProjectLoaderError("io_error", "Transaction failed", err);
+  }
+}
+async function runTransaction(root, operations) {
+  const wrapDir = resolve2(root, ".story");
+  await withLock(wrapDir, async () => {
+    await runTransactionUnlocked(root, operations);
+  });
+}
 async function doRecoverTransaction(wrapDir) {
   const journalPath = join3(wrapDir, ".txn.json");
   let entries;
@@ -996,6 +1080,15 @@ async function atomicWrite(targetPath, content) {
     );
   }
 }
+async function fsyncWrite(filePath, content) {
+  const fh = await open(filePath, "w");
+  try {
+    await fh.writeFile(content, "utf-8");
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+}
 async function guardPath(target, root) {
   let resolvedRoot;
   try {
@@ -4739,6 +4832,19 @@ async function handleReportPlan(root, dir, state, report) {
     });
   }
   const risk = assessRisk(void 0, void 0);
+  if (state.ticket) {
+    try {
+      const { withProjectLock: withProjectLock2, writeTicketUnlocked: writeTicketUnlocked2 } = await Promise.resolve().then(() => (init_project_loader(), project_loader_exports));
+      await withProjectLock2(root, { strict: false }, async ({ state: projectState }) => {
+        const ticket = projectState.ticketByID(state.ticket.id);
+        if (ticket && ticket.status !== "inprogress") {
+          const updated = { ...ticket, status: "inprogress" };
+          await writeTicketUnlocked2(updated, root);
+        }
+      });
+    } catch {
+    }
+  }
   const written = writeSessionSync(dir, {
     ...state,
     state: "PLAN_REVIEW",
@@ -5096,11 +5202,11 @@ async function handleReportComplete(root, dir, state, report) {
   const maxTickets = updated.config.maxTicketsPerSession;
   let nextState;
   let advice = "ok";
-  if (pressure === "critical") {
+  if (maxTickets > 0 && ticketsDone >= maxTickets) {
     nextState = "HANDOVER";
-    advice = "compact-now";
-  } else if (maxTickets > 0 && ticketsDone >= maxTickets) {
+  } else if (pressure === "critical") {
     nextState = "HANDOVER";
+    advice = "compact-now";
   } else if (pressure === "high") {
     advice = "consider-compact";
     nextState = "PICK_TICKET";
@@ -5180,6 +5286,36 @@ async function handleReportHandover(root, dir, state, report) {
     } catch {
     }
   }
+  const pressureLevel = state.contextPressure?.level ?? "low";
+  const maxTickets = state.config.maxTicketsPerSession;
+  const capReached = maxTickets > 0 && state.completedTickets.length >= maxTickets;
+  let hasMoreTickets = false;
+  try {
+    const { state: ps } = await loadProject(root);
+    hasMoreTickets = nextTickets(ps, 1).kind === "found";
+  } catch {
+  }
+  if (pressureLevel === "critical" && hasMoreTickets && !capReached) {
+    return guideResult(state, "HANDOVER", {
+      instruction: [
+        "# Context Compaction Needed",
+        "",
+        `${state.completedTickets.length} ticket(s) completed so far. Handover written. Context is large \u2014 time to compact and continue.`,
+        "",
+        'Call `claudestory_autonomous_guide` with `action: "pre_compact"` now:',
+        "```json",
+        `{ "sessionId": "${state.sessionId}", "action": "pre_compact" }`,
+        "```",
+        "",
+        'After pre_compact responds, run `/compact`, then call with `action: "resume"` to continue working on more tickets.'
+      ].join("\n"),
+      reminders: [
+        "Do NOT stop. This is a context compaction, not a session end.",
+        "Call pre_compact \u2192 /compact \u2192 resume to continue autonomous work."
+      ],
+      contextAdvice: "compact-now"
+    });
+  }
   const written = writeSessionSync(dir, {
     ...state,
     state: "SESSION_END",
@@ -5227,6 +5363,40 @@ async function handleResume(root, args) {
     resumeFromRevision: null,
     contextPressure: { ...info.state.contextPressure, compactionCount: (info.state.contextPressure?.compactionCount ?? 0) + 1 }
   });
+  if (resumeState === "PICK_TICKET") {
+    let candidatesText = "No ticket candidates available.";
+    let topCandidate = null;
+    try {
+      const { state: ps } = await loadProject(root);
+      const result = nextTickets(ps, 5);
+      if (result.kind === "found") {
+        topCandidate = result.candidates[0] ?? null;
+        candidatesText = result.candidates.map(
+          (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type})`
+        ).join("\n");
+      }
+    } catch {
+    }
+    return guideResult(written, "PICK_TICKET", {
+      instruction: [
+        "# Resumed After Compact \u2014 Continue Working",
+        "",
+        `${written.completedTickets.length} ticket(s) done so far. Context compacted. Pick the next ticket immediately.`,
+        "",
+        candidatesText,
+        "",
+        topCandidate ? `Pick **${topCandidate.ticket.id}** by calling \`claudestory_autonomous_guide\` now:` : "Pick a ticket now:",
+        "```json",
+        topCandidate ? `{ "sessionId": "${written.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "${topCandidate.ticket.id}" } }` : `{ "sessionId": "${written.sessionId}", "action": "report", "report": { "completedAction": "ticket_picked", "ticketId": "T-XXX" } }`,
+        "```"
+      ].join("\n"),
+      reminders: [
+        "Do NOT stop or summarize. Pick the next ticket IMMEDIATELY.",
+        "Do NOT ask the user for confirmation.",
+        "You are in autonomous mode \u2014 continue working."
+      ]
+    });
+  }
   return guideResult(written, resumeState, {
     instruction: [
       "# Resumed After Compact",
@@ -5238,6 +5408,7 @@ async function handleResume(root, args) {
     ].join("\n"),
     reminders: [
       "Do NOT use plan mode.",
+      "Do NOT stop or summarize.",
       "Call autonomous_guide after completing each step."
     ]
   });
@@ -5253,11 +5424,12 @@ async function handlePreCompact(root, args) {
     return guideError(new Error(`Session ${args.sessionId} is already in COMPACT state. Call action: "resume" to continue.`));
   }
   const headResult = await gitHead(root);
+  const resumeTarget = info.state.state === "HANDOVER" ? "PICK_TICKET" : info.state.state;
   const written = writeSessionSync(info.dir, {
     ...refreshLease(info.state),
     state: "COMPACT",
     previousState: info.state.state,
-    preCompactState: info.state.state,
+    preCompactState: resumeTarget,
     resumeFromRevision: info.state.revision,
     git: {
       ...info.state.git,
@@ -6034,7 +6206,7 @@ async function ensureGitignoreEntries(gitignorePath, entries) {
 // src/mcp/index.ts
 var ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
 var CONFIG_PATH2 = ".story/config.json";
-var version = "0.1.14";
+var version = "0.1.16";
 function tryDiscoverRoot() {
   const envRoot = process.env[ENV_VAR2];
   if (envRoot) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anthropologies/claudestory",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "license": "UNLICENSED",
   "description": "Cross-session context persistence for AI coding projects. Tracks tickets, issues, roadmap, and handovers so every session builds on the last.",
   "keywords": [