@khalilgharbaoui/opencode-claude-code-plugin 0.38.0 → 0.39.0

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/claude-code-language-model.ts
+import { join as join11 } from "path";
+
 // src/ids.ts
 import { randomInt } from "crypto";
 var ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -72,6 +75,14 @@ function parseInput(raw) {
     return {};
   }
 }
+function hostedToolResult(part) {
+  const result = part.result;
+  if (part.providerExecuted !== true) return part.result;
+  if (!result || typeof result !== "object" || typeof result.output !== "string") {
+    return part.result;
+  }
+  return result.output;
+}
 function createHostToolPartTranslator(dialect = "v1") {
   if (dialect !== "v2") return (part) => part;
   const dropped = /* @__PURE__ */ new Set();
@@ -118,7 +129,8 @@ function createHostToolPartTranslator(dialect = "v1") {
       case "tool-result": {
         const tool = classify2(String(part.toolCallId), part.toolName);
         if (tool === null) return null;
-        return tool ? { ...part, toolName: tool.name } : part;
+        const result = hostedToolResult(part);
+        return tool ? { ...part, toolName: tool.name, result } : { ...part, result };
       }
       default:
         return part;
@@ -4259,6 +4271,11 @@ function findForkParent(opts) {
   }
   return best;
 }
+function continuesRecordedConversation(recorded, prompt) {
+  const { history, forkable } = splitForkHistory(prompt);
+  if (!forkable || recorded.length === 0 || recorded.length > history.length) return false;
+  return isPrefix(recorded, history) && tailIsReplyOnly(history, recorded.length);
+}
 function isPrefix(recorded, history) {
   for (let i = 0; i < recorded.length; i++) {
     if (recorded[i].role !== history[i].role) return false;
@@ -4273,6 +4290,109 @@ function tailIsReplyOnly(history, from) {
   return true;
 }
 
+// src/session-resume-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+var MAX_RESUME_RECORDS = 256;
+var RESUME_RECORD_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var records = null;
+var pathOverride = null;
+function resumeStorePath() {
+  if (pathOverride) return pathOverride;
+  const stateRoot = process.env.XDG_STATE_HOME || join5(homedir4(), ".local", "state");
+  return join5(stateRoot, "opencode-claude-code-plugin", "claude-sessions.json");
+}
+function isDigest(value) {
+  const entry = value;
+  return !!entry && (entry.role === "user" || entry.role === "assistant" || entry.role === "tool") && typeof entry.digest === "string";
+}
+function isRecord2(value) {
+  const record = value;
+  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest);
+}
+function load() {
+  if (records) return records;
+  records = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync2(resumeStorePath(), "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
+    if (entries && typeof entries === "object") {
+      const cutoff = Date.now() - RESUME_RECORD_MAX_AGE_MS;
+      const valid = Object.entries(entries).filter((entry) => isRecord2(entry[1])).filter(([, record]) => record.updatedAt >= cutoff).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+      for (const [key, record] of valid) records.set(key, record);
+    }
+  } catch {
+  }
+  return records;
+}
+function save(update) {
+  const file = resumeStorePath();
+  const merged = /* @__PURE__ */ new Map();
+  try {
+    const onDisk = JSON.parse(readFileSync2(file, "utf8"))?.sessions;
+    if (onDisk && typeof onDisk === "object") {
+      for (const [key, record] of Object.entries(onDisk)) {
+        if (isRecord2(record)) merged.set(key, record);
+      }
+    }
+  } catch {
+  }
+  update(merged);
+  const cutoff = Date.now() - RESUME_RECORD_MAX_AGE_MS;
+  const kept = [...merged.entries()].filter(([, record]) => record.updatedAt >= cutoff).sort((a, b) => a[1].updatedAt - b[1].updatedAt).slice(-MAX_RESUME_RECORDS);
+  records = new Map(kept);
+  try {
+    mkdirSync3(join5(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync3(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+      mode: 384
+    });
+    renameSync2(tmp, file);
+  } catch (err) {
+    log.debug("could not write the claude session resume store", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath) {
+  const chain = conversationDigests(prompt);
+  if (chain.length === 0) return;
+  const current = load().get(sessionKey2);
+  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
+    return;
+  }
+  save((merged) => {
+    merged.delete(sessionKey2);
+    merged.set(sessionKey2, { claudeSessionId, cliPath, chain, updatedAt: Date.now() });
+  });
+}
+function forgetResumePoint(sessionKey2) {
+  if (!load().has(sessionKey2)) return;
+  save((merged) => {
+    merged.delete(sessionKey2);
+  });
+}
+function findResumePoint(opts) {
+  const record = load().get(opts.sessionKey);
+  if (!record) return void 0;
+  const refuse = (reason) => {
+    log.info("not resuming the claude session from before the restart", {
+      sessionKey: opts.sessionKey,
+      reason
+    });
+    return void 0;
+  };
+  if (record.cliPath !== opts.cliPath) return refuse("another claude binary");
+  if (!continuesRecordedConversation(record.chain, opts.prompt)) {
+    return refuse("the conversation changed");
+  }
+  if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
+    return refuse("the transcript is gone");
+  }
+  return { claudeSessionId: record.claudeSessionId, matched: record.chain.length };
+}
+
 // src/permission-presets.ts
 var READ_ONLY_DISALLOWED_CLI_TOOLS = [
   "Bash",
@@ -4385,7 +4505,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 var MAX_HISTORY_EXCHANGES = 20;
 var SIDE_QUESTION_USAGE = "Usage: /btw <question>. Ask a side question about the current conversation without adding it to the main context.";
 var pendingProcesses = /* @__PURE__ */ new WeakSet();
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var SYSTEM_REMINDER_BLOCK = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -4396,7 +4516,7 @@ function parseSideQuestionContent(content) {
   } else if (Array.isArray(content)) {
     const parts = [];
     for (const part of content) {
-      if (!isRecord2(part) || part.type !== "text" || typeof part.text !== "string") return null;
+      if (!isRecord3(part) || part.type !== "text" || typeof part.text !== "string") return null;
       parts.push(part.text);
     }
     text = parts.join("\n");
@@ -4415,7 +4535,7 @@ function assistantText(content) {
   if (!Array.isArray(content)) return "";
   const parts = [];
   for (const part of content) {
-    if (isRecord2(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
+    if (isRecord3(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
   }
   return parts.join("\n").trim();
 }
@@ -4445,9 +4565,9 @@ function dispatchSideQuestionResponse(activeProcess, line) {
   } catch {
     return false;
   }
-  if (!isRecord2(message) || message.type !== "control_response") return false;
+  if (!isRecord3(message) || message.type !== "control_response") return false;
   const response = message.response;
-  if (!isRecord2(response) || typeof response.request_id !== "string") return false;
+  if (!isRecord3(response) || typeof response.request_id !== "string") return false;
   return activeProcess.lineEmitter.emit(`side-question:${response.request_id}`, response);
 }
 async function requestSideQuestion(activeProcess, question, options) {
@@ -4532,7 +4652,7 @@ async function requestSideQuestion(activeProcess, question, options) {
         return;
       }
       const result = response.response;
-      if (response.subtype !== "success" || !isRecord2(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
+      if (response.subtype !== "success" || !isRecord3(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
         fail(new Error("Claude Code returned an invalid /btw response."));
         return;
       }
@@ -4702,6 +4822,7 @@ function noteTurnLine(ap, line) {
   if (isTerminalResultLine(line)) settleTurn(ap);
 }
 function isTurnInFlight(ap) {
+  if (ap.interactiveControl) return ap.interactiveControl.turnRunning();
   return ap.turnInFlight === true;
 }
 function awaitTurnIdle(ap, timeoutMs) {
@@ -4721,6 +4842,7 @@ function awaitTurnIdle(ap, timeoutMs) {
   });
 }
 function interruptTurn(ap, timeoutMs = TURN_INTERRUPT_TIMEOUT_MS) {
+  if (ap.interactiveControl) return ap.interactiveControl.interrupt(timeoutMs);
   if (!ap.turnInFlight) return Promise.resolve(true);
   const stdin = ap.proc.stdin;
   if (ap.asideTransport?.interactive || !stdin || !stdin.writable) {
@@ -4761,6 +4883,15 @@ function setActiveProcess(key, ap) {
   cancelIdleProcessEviction(key);
   activeProcesses.set(key, ap);
 }
+function noteInteractiveProcessExit(sessionKey2, ap, code) {
+  if (activeProcesses.get(sessionKey2) !== ap) return;
+  cancelIdleProcessEviction(sessionKey2);
+  activeProcesses.delete(sessionKey2);
+  if (code !== 0 && code !== null) {
+    claudeSessions.delete(sessionKey2);
+    forgetResumePoint(sessionKey2);
+  }
+}
 function scheduleIdleProcessEviction(key, timeoutMs) {
   cancelIdleProcessEviction(key);
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_IDLE_TIMEOUT_MS) {
@@ -4906,6 +5037,7 @@ function deleteClaudeSessionId(key) {
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
   forgetForkFingerprint(key);
+  forgetResumePoint(key);
 }
 function effortSessionKey(baseKey, effort) {
   return effort ? `${baseKey}::effort=${effort}` : baseKey;
@@ -5018,6 +5150,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
         sessionKey: sessionKey2
       });
       claudeSessions.delete(sessionKey2);
+      forgetResumePoint(sessionKey2);
     }
   });
   proc.stderr?.on("data", (data) => {
@@ -5032,6 +5165,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
           error: stderr.slice(0, 200)
         });
         claudeSessions.delete(sessionKey2);
+        forgetResumePoint(sessionKey2);
       } else {
         log.debug("ignoring session ID error from stale claude process", {
           sessionKey: sessionKey2
@@ -5510,7 +5644,7 @@ async function handleBtwCommand(client, input, options = {}) {
 // src/diagnostic-bundle.ts
 import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { openSync, readSync, closeSync, fstatSync, realpathSync } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 
 // src/log-messages.ts
 var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
@@ -5586,6 +5720,9 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "ignoring unknown proxyTools entries",
   "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI",
   "interactive system prompt disabled; opencode agent prompts will not be appended",
+  "interactive transport cancelled the usage-limit auto-continue",
+  "interactive transport cannot continue",
+  "interactive transport denied a permission prompt",
   "interactive transport dropped non-text content blocks",
   "interactive turn failed",
   "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI",
@@ -5617,6 +5754,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "remote URL images are not supported by Claude CLI, skipping",
   "replaying stdout the child emitted between turns",
   "result fallback timer fired \u2014 closing stream without result event",
+  "resuming the claude session from before the restart instead of replaying it",
   "shared Claude capability already exists; leaving untouched",
   "skipping MCP server with unknown type",
   "skipping local MCP server with no command",
@@ -5840,7 +5978,7 @@ function createIdHasher(salt = randomBytes2(16).toString("hex")) {
   return (raw) => createHash4("sha256").update(salt).update("\0").update(raw).digest("hex").slice(0, 8);
 }
 function createRedactionContext(options = {}) {
-  const home = options.home ?? homedir4();
+  const home = options.home ?? homedir5();
   const homes = /* @__PURE__ */ new Set();
   if (home) homes.add(home);
   if (home) {
@@ -6514,7 +6652,7 @@ function staleBuildWatch() {
 var DOCTOR_COMMAND = "claude-code-doctor";
 var DOCTOR_COMMAND_DESCRIPTION = "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls. Add `usage` for plan windows, or `bundle` for a redacted log you can paste into an issue";
 var DOCTOR_MARKER = "\u258C **claude-code doctor**";
-function isRecord3(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var SYSTEM_REMINDER_BLOCK2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -6525,7 +6663,7 @@ function parseDoctorCommandContent(content) {
   } else if (Array.isArray(content)) {
     const parts = [];
     for (const part of content) {
-      if (!isRecord3(part) || part.type !== "text" || typeof part.text !== "string") return null;
+      if (!isRecord4(part) || part.type !== "text" || typeof part.text !== "string") return null;
       parts.push(part.text);
     }
     text = parts.join("\n");
@@ -7266,8 +7404,8 @@ var registry = {};
 var defaultSubagentModel;
 var defaultSubagentCacheTtl;
 var providerFallbackModels = [];
-function setAgentRegistry(records) {
-  registry = records;
+function setAgentRegistry(records2) {
+  registry = records2;
 }
 function getAgentRegistry() {
   return registry;
@@ -7407,7 +7545,7 @@ function parseFallbackModelList(value) {
   return value.trim().replace(/^\[|\]$/g, "").split(/[,\s]+/).map((entry) => entry.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
 }
 async function readAgentMarkdownRecords(directories) {
-  const records = {};
+  const records2 = {};
   for (const directory of directories) {
     let entries;
     try {
@@ -7418,10 +7556,10 @@ async function readAgentMarkdownRecords(directories) {
     for (const entry of entries) {
       if (!entry.endsWith(".md")) continue;
       const name = entry.slice(0, -3);
-      if (records[name]) continue;
+      if (records2[name]) continue;
       try {
         const text = await readFile(path7.join(directory, entry), "utf8");
-        records[name] = parseAgentFrontmatter(text);
+        records2[name] = parseAgentFrontmatter(text);
       } catch (err) {
         log.debug("failed to read agent markdown", {
           file: path7.join(directory, entry),
@@ -7430,7 +7568,7 @@ async function readAgentMarkdownRecords(directories) {
       }
     }
   }
-  return records;
+  return records2;
 }
 function agentDirectories(home, projectDirectory) {
   const directories = [];
@@ -8369,6 +8507,7 @@ async function resolveSkillPluginDirs(opts) {
 
 // src/claude-session-wrapper.ts
 import { EventEmitter as EventEmitter4 } from "events";
+import { existsSync as existsSync4 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
 
 // src/claude-session-bun.ts
@@ -8402,10 +8541,99 @@ function encodeCwd(cwd) {
   }
   return real.replace(/[^a-zA-Z0-9]/g, "-");
 }
+var bunPtySpawner = (argv, opts) => {
+  const [command, ...args] = argv;
+  return Bun.spawn([resolveClaude(command ?? "claude"), ...args], {
+    cwd: opts.cwd,
+    env: opts.env,
+    terminal: {
+      cols: opts.cols,
+      rows: opts.rows,
+      data: (_term, data) => opts.onData(Buffer.from(data).toString("utf8"))
+    }
+  });
+};
+function words(text) {
+  return text.split(/\s+/).map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s*");
+}
+var SCREEN_PATTERNS = [
+  {
+    kind: "login",
+    pattern: new RegExp(
+      [
+        words("Select login method"),
+        words("Please run /login"),
+        words("Invalid API key"),
+        words("OAuth token has expired"),
+        words("Not logged in")
+      ].join("|"),
+      "i"
+    )
+  },
+  {
+    kind: "onboarding",
+    pattern: new RegExp(
+      [words("Choose the text style that looks best"), words("Let's get started.")].join("|"),
+      "i"
+    )
+  },
+  {
+    kind: "trust",
+    pattern: new RegExp(
+      [
+        words("Do you trust the files in this folder?"),
+        words("Is this a project you created or one you trust?"),
+        words("Yes, I trust this folder")
+      ].join("|"),
+      "i"
+    )
+  },
+  {
+    // The question alone is not enough: Claude can write "Do you want to
+    // proceed?" in a reply. The dialog always numbers its options.
+    kind: "permission",
+    pattern: new RegExp(
+      `${words("Do you want to")}\\s*(?:proceed|make\\s*this\\s*edit|create|overwrite|allow|run)[^?]{0,160}\\?[\\s\\S]{0,600}?1\\.\\s*Yes`,
+      "i"
+    )
+  },
+  {
+    kind: "auto-continue",
+    pattern: new RegExp(
+      `${words("continuing automatically at")}[^\xB7\\n]{1,40}\xB7\\s*${words("esc to cancel")}`,
+      "i"
+    )
+  }
+];
+function stripTerminal(raw) {
+  return raw.replace(
+    /\x1B\[(\d*)C/g,
+    (_match, count) => " ".repeat(Math.min(Number(count) || 1, 200))
+  ).replace(/\x1B\[[0-9;?]*[ABDEFGHJKfd]/g, "\n").replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "").replace(/[ \t]+/g, " ");
+}
+function highlightedChoice(text) {
+  let last = null;
+  for (const match of text.matchAll(/❯\s*(?:\d+\s*\.\s*)?(Yes|No)\b/gi)) {
+    last = match[1].toLowerCase();
+  }
+  return last === "yes" || last === "no" ? last : null;
+}
+function classifyScreen(text) {
+  for (const { kind, pattern } of SCREEN_PATTERNS) {
+    const match = pattern.exec(text);
+    if (match) {
+      return { kind, detail: match[0].replace(/\s+/g, " ").trim().slice(0, 200) };
+    }
+  }
+  return null;
+}
+function configDirEnv(configDir) {
+  return configDir ? { CLAUDE_CONFIG_DIR: configDir } : {};
+}
 function interactiveSpawnEnv(opts) {
   return {
     ...process.env,
-    CLAUDE_CONFIG_DIR: opts.configDir,
+    ...configDirEnv(opts.configDir),
     TERM: "xterm-256color",
     // Pin the binary so a mid-session autoupdate cannot invalidate the
     // detected version the flag gates read, and skip non-essential traffic.
@@ -8480,6 +8708,21 @@ var TurnUsageAccumulator = class {
 };
 var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+var RAW_KEEP_CHARS = 64 * 1024;
+var SCREEN_WINDOW_CHARS = 16 * 1024;
+var INTERRUPT_MARKER = "[Request interrupted by user";
+function isInterruptRecord(rec) {
+  if (!rec || rec.type !== "user" || !rec.message) return false;
+  const content = rec.message.content;
+  if (typeof content === "string") return content.startsWith(INTERRUPT_MARKER);
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (block) => block?.type === "text" && typeof block.text === "string" && block.text.startsWith(INTERRUPT_MARKER)
+  );
+}
+function isTurnDurationRecord(rec) {
+  return rec?.type === "system" && rec.subtype === "turn_duration";
+}
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
   if (!value) return path9.join(os4.homedir(), ".claude");
@@ -8489,11 +8732,21 @@ function resolveConfigDir(configDir) {
   }
   return path9.resolve(value);
 }
+function fatalScreenMessage(kind, configDir, cwd) {
+  if (kind === "trust") {
+    return `Claude Code's folder trust dialog for ${cwd} could not be answered. Run \`claude\` in that folder once by hand and trust it, then retry.`;
+  }
+  if (kind === "login") {
+    return `Claude Code is not logged in for ${configDir}. Run \`claude\` there once by hand and log in (or \`claude auth login\`), then retry.`;
+  }
+  return `Claude Code has not finished its first-run setup for ${configDir}. Run \`claude\` there once by hand, then retry.`;
+}
 var ClaudeSession = class {
   sessionId;
   cwd;
   configDir;
   jsonlPath;
+  /** The newest terminal output, ANSI included, for diagnostics. */
   raw = "";
   proc = null;
   cursor = 0;
@@ -8503,12 +8756,36 @@ var ClaudeSession = class {
   exitCode = null;
   aborted = false;
   signal;
+  resumeSessionId;
+  env;
+  onScreen;
+  onExit;
+  spawnPty;
+  /** The configured config dir, which alone is exported to the child. */
+  explicitConfigDir;
+  /** Output since the screen was last acted on, read by `checkScreen`. */
+  screen = "";
+  screenTimer = null;
+  fatal = null;
+  /** The folder trust dialog is up and not answered yet. */
+  trustPending = false;
+  trustMoves = 0;
+  trustMovedAt = 0;
+  turn = null;
+  turnDenied = [];
+  abandonTurn = false;
   o;
   constructor(opts = {}) {
     this.cwd = path9.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
+    this.explicitConfigDir = opts.configDir ? this.configDir : void 0;
     this.signal = opts.signal;
-    this.sessionId = randomUUID4();
+    this.resumeSessionId = opts.resumeSessionId;
+    this.env = opts.env;
+    this.onScreen = opts.onScreen;
+    this.onExit = opts.onExit;
+    this.spawnPty = opts.spawnPty ?? bunPtySpawner;
+    this.sessionId = opts.resumeSessionId ?? randomUUID4();
     this.jsonlPath = path9.join(
       this.configDir,
       "projects",
@@ -8538,9 +8815,47 @@ var ClaudeSession = class {
       submitMinMs: opts.submitMinMs ?? 200,
       submitConfirmMs: opts.submitConfirmMs ?? 1500,
       submitMaxRetries: opts.submitMaxRetries ?? 8,
-      debug: opts.debug ?? false
+      debug: opts.debug ?? false,
+      // The headless CLI's `tool_progress` heartbeat runs every 30 s, and the
+      // wire-inactivity watchdog it keeps quiet fires at 60 s.
+      heartbeatMs: opts.heartbeatMs ?? 3e4,
+      interruptGraceMs: opts.interruptGraceMs ?? 5e3,
+      // Shorter than `bootQuietMs`, so a trust dialog is answered before boot
+      // could declare the TUI ready and paste a prompt into it.
+      permissionQuietMs: opts.permissionQuietMs ?? 1e3,
+      stopSettleMs: opts.stopSettleMs ?? 750
     };
   }
+  /** The CLI arguments this session spawns with. */
+  spawnArgs() {
+    const args = this.resumeSessionId ? ["--resume", this.resumeSessionId] : ["--session-id", this.sessionId];
+    if (this.o.model) args.push("--model", this.o.model);
+    if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
+      args.push("--setting-sources", this.o.settingSources);
+    }
+    if (this.o.extraArgs && this.o.extraArgs.length) args.push(...this.o.extraArgs);
+    return args;
+  }
+  /** The child environment: the caller's (or the default one) plus `TERM`,
+   *  and `CLAUDE_CONFIG_DIR` only for a configured one (`configDirEnv`). */
+  spawnEnv() {
+    if (!this.env) {
+      return interactiveSpawnEnv({
+        configDir: this.explicitConfigDir,
+        ignoreAnthropicApiKey: this.o.ignoreAnthropicApiKey,
+        effort: this.o.effort
+      });
+    }
+    return { ...this.env, ...configDirEnv(this.explicitConfigDir), TERM: "xterm-256color" };
+  }
+  /** True while a turn is between its paste and its end. */
+  get turnRunning() {
+    return this.turn !== null;
+  }
+  /** True once the child is gone (exited, killed or never started). */
+  get hasExited() {
+    return this.exited;
+  }
   async start() {
     if (this.signal?.aborted) throw new Error("aborted before start");
     this.signal?.addEventListener(
@@ -8551,61 +8866,147 @@ var ClaudeSession = class {
       },
       { once: true }
     );
-    const claude = resolveClaude(this.o.cliPath ?? "claude");
-    const args = ["--session-id", this.sessionId];
-    if (this.o.model) args.push("--model", this.o.model);
-    if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
-      args.push("--setting-sources", this.o.settingSources);
-    }
-    if (this.o.extraArgs && this.o.extraArgs.length) args.push(...this.o.extraArgs);
+    const claude = this.o.cliPath ?? "claude";
+    const args = this.spawnArgs();
     if (this.o.debug)
       process.stderr.write(`[session] spawn: ${claude} ${args.join(" ")}
 `);
     this.lastDataAt = Date.now();
-    this.proc = Bun.spawn([claude, ...args], {
+    const proc = this.spawnPty([claude, ...args], {
       cwd: this.cwd,
-      env: interactiveSpawnEnv({
-        // The resolved field, not `this.o.configDir`: same value (the
-        // constructor copies it in) but typed as always present.
-        configDir: this.configDir,
-        ignoreAnthropicApiKey: this.o.ignoreAnthropicApiKey,
-        effort: this.o.effort
-      }),
-      terminal: {
-        cols: this.o.cols,
-        rows: this.o.rows,
-        data: (_term, d) => {
-          this.lastDataAt = Date.now();
-          const chunk = Buffer.from(d).toString("utf8");
-          this.raw += chunk;
-          if (this.o.debug) process.stdout.write(chunk);
-        }
-      }
+      env: this.spawnEnv(),
+      cols: this.o.cols,
+      rows: this.o.rows,
+      onData: (chunk) => this.onData(chunk)
     });
-    this.proc.exited.then((code) => {
-      this.exitCode = typeof code === "number" ? code : null;
-      this.exited = true;
-      this.proc = null;
-    }).catch(() => {
+    this.proc = proc;
+    const markExited = (code) => {
+      if (this.exited) return;
+      this.exitCode = code;
       this.exited = true;
       this.proc = null;
-    });
+      this.clearScreenTimer();
+      this.onExit?.(code);
+    };
+    proc.exited.then((code) => markExited(typeof code === "number" ? code : null)).catch(() => markExited(null));
     await this.waitForBoot();
     this.cursor = this.lineCount();
   }
+  onData(chunk) {
+    this.lastDataAt = Date.now();
+    this.raw = (this.raw + chunk).slice(-RAW_KEEP_CHARS);
+    this.screen = (this.screen + chunk).slice(-SCREEN_WINDOW_CHARS);
+    if (this.o.debug) process.stdout.write(chunk);
+    this.clearScreenTimer();
+    this.screenTimer = setTimeout(() => {
+      this.screenTimer = null;
+      this.checkScreen();
+    }, this.o.permissionQuietMs);
+  }
+  clearScreenTimer() {
+    if (this.screenTimer) {
+      clearTimeout(this.screenTimer);
+      this.screenTimer = null;
+    }
+  }
+  /**
+   * Answer the screen the TUI is blocked on, if it is one of the few this
+   * session recognises. Returns what it did, or null. Each screen is acted on
+   * once: the window is cleared afterwards, so the next check only reads what
+   * the TUI drew since.
+   */
+  checkScreen() {
+    if (!this.proc || this.exited) return null;
+    const text = stripTerminal(this.screen);
+    const state = this.trustPending ? { kind: "trust", detail: "folder trust dialog" } : classifyScreen(text);
+    if (!state) return null;
+    let action;
+    switch (state.kind) {
+      case "trust": {
+        this.trustPending = true;
+        const choice = highlightedChoice(text);
+        if (choice === "yes") {
+          this.write("\r");
+          this.trustPending = false;
+          action = "accepted";
+          break;
+        }
+        if (choice === null) return null;
+        if (this.trustMovedAt && this.lastDataAt <= this.trustMovedAt) return null;
+        if (this.trustMoves >= 4) {
+          action = "fatal";
+          break;
+        }
+        this.trustMoves++;
+        this.trustMovedAt = Date.now();
+        this.write("\x1B[B");
+        return null;
+      }
+      case "permission":
+        if (!this.turn) return null;
+        this.write("\x1B");
+        this.turnDenied.push(state);
+        action = "denied";
+        break;
+      case "auto-continue":
+        this.write("\x1B");
+        action = "cancelled";
+        break;
+      case "login":
+      case "onboarding":
+        action = "fatal";
+        break;
+    }
+    this.screen = "";
+    const event = { ...state, action };
+    if (action === "fatal") {
+      this.fatal = event;
+      this.killProcess();
+    }
+    try {
+      this.onScreen?.(event);
+    } catch {
+    }
+    return event;
+  }
+  write(data) {
+    try {
+      this.proc?.terminal.write(data);
+    } catch {
+    }
+  }
+  fatalError() {
+    if (!this.fatal) return null;
+    return new Error(
+      this.failureMessage(fatalScreenMessage(this.fatal.kind, this.configDir, this.cwd), true)
+    );
+  }
   /** Wait until the TUI has been quiet for bootQuietMs (Ink ready), bounded by
-   *  bootMinMs..bootMaxMs. */
+   *  bootMinMs..bootMaxMs. A screen still waiting to be answered when the TUI
+   *  goes quiet is answered first, and the wait goes on. */
   async waitForBoot() {
     const start = Date.now();
     while (Date.now() - start < this.o.bootMaxMs) {
       await delay(150);
       if (this.aborted) throw new Error("aborted during boot");
+      const fatal = this.fatalError();
+      if (fatal) throw fatal;
       if (this.exited) {
         throw new Error(this.failureMessage("claude exited during boot", true));
       }
       const elapsed = Date.now() - start;
       const sinceData = Date.now() - this.lastDataAt;
-      if (elapsed >= this.o.bootMinMs && sinceData >= this.o.bootQuietMs) return;
+      if (elapsed >= this.o.bootMinMs && sinceData >= this.o.bootQuietMs) {
+        const acted = this.checkScreen();
+        if (!acted && !this.trustPending) return;
+        const fatalNow = this.fatalError();
+        if (fatalNow) throw fatalNow;
+      }
+    }
+    if (this.trustPending) {
+      this.fatal = { kind: "trust", detail: "folder trust dialog", action: "fatal" };
+      this.killProcess();
+      throw this.fatalError();
     }
   }
   /** Submit the freshly-injected prompt and confirm the turn was actually
@@ -8643,7 +9044,7 @@ var ClaudeSession = class {
     return lines.length > 0 ? lines.length - 1 : 0;
   }
   rawTail(max = 600) {
-    const clean = this.raw.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\s+/g, " ").trim();
+    const clean = stripTerminal(this.raw).replace(/\s+/g, " ").trim();
     return clean.length > max ? clean.slice(-max) : clean;
   }
   failureMessage(reason, includeRaw = false) {
@@ -8657,61 +9058,133 @@ var ClaudeSession = class {
     return parts.join("; ");
   }
   /**
-   * Inject a turn into the live session and return the assistant reply once a
-   * terminal stop_reason is observed in the transcript.
+   * Paste a turn into the live session and follow the transcript until the
+   * turn ends, handing every new record to `onRecord` (raw line and parsed
+   * record, the latter null when the line is not JSON). One turn at a time:
+   * a second call while one runs is refused, because both would read the
+   * same cursor.
    */
-  async ask(prompt, perTurnTimeoutMs) {
+  async runTurnLoop(prompt, onRecord, timeout, onHeartbeat) {
     if (this.aborted) throw new Error("aborted");
+    const fatal = this.fatalError();
+    if (fatal) throw fatal;
     if (!this.proc || this.exited)
       throw new Error("session not started or already exited");
-    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
-    const t0 = Date.now();
-    if (this.o.bracketedPaste) {
-      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
-    } else {
-      this.proc.terminal.write(prompt);
-    }
-    await this.submitTurn();
-    const collected2 = [];
-    const usage = new TurnUsageAccumulator();
-    let stopReason = null;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      await delay(this.o.pollMs);
-      if (this.aborted) throw new Error("aborted mid-turn");
-      const lines = this.readRawLines();
-      const lastComplete = lines.length - 1;
-      if (lastComplete <= this.cursor) {
-        if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
-        continue;
+    if (this.turn) throw new Error("a turn is already running in this session");
+    let settle;
+    this.turn = new Promise((resolve6) => settle = resolve6);
+    this.turnDenied = [];
+    this.abandonTurn = false;
+    this.cursor = Math.max(this.cursor, this.lineCount());
+    this.screen = "";
+    try {
+      if (this.o.bracketedPaste) {
+        this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
+      } else {
+        this.proc.terminal.write(prompt);
       }
-      for (let i = this.cursor; i < lastComplete; i++) {
-        const s = lines[i];
-        if (!s || !s.trim()) continue;
-        let rec;
-        try {
-          rec = JSON.parse(s);
-        } catch {
+      await this.submitTurn();
+      let stopReason = null;
+      let stopSeenAt = 0;
+      let end = null;
+      let sawUserRecord = false;
+      let lastBeat = Date.now();
+      const deadline = Date.now() + timeout;
+      while (Date.now() < deadline) {
+        await delay(this.o.pollMs);
+        if (this.aborted) throw new Error("aborted mid-turn");
+        const fatalNow = this.fatalError();
+        if (fatalNow) throw fatalNow;
+        const lines = this.readRawLines();
+        const lastComplete = lines.length - 1;
+        if (lastComplete > this.cursor) {
+          for (let i = this.cursor; i < lastComplete && !end; i++) {
+            const s = lines[i];
+            if (!s || !s.trim()) continue;
+            let rec = null;
+            try {
+              rec = JSON.parse(s);
+            } catch {
+            }
+            onRecord(s, rec);
+            if (!rec) continue;
+            if (rec.type === "assistant" && rec.message) {
+              const reason = rec.message.stop_reason;
+              if (typeof reason === "string") {
+                stopReason = TERMINAL_STOP.has(reason) ? reason : null;
+              }
+            } else if (rec.type === "user") {
+              if (sawUserRecord && isInterruptRecord(rec)) end = "interrupted";
+              sawUserRecord = true;
+            } else if ((sawUserRecord || stopReason) && isTurnDurationRecord(rec)) {
+              end = stopReason ? "stop" : "ended";
+            }
+            this.cursor = i + 1;
+          }
+          if (!end) this.cursor = lastComplete;
+          lastBeat = Date.now();
+          stopSeenAt = Date.now();
+          if (end) return { stopReason: end === "stop" ? stopReason : null, end, denied: this.turnDenied };
           continue;
         }
-        if (rec.type === "assistant" && rec.message) {
-          for (const b of rec.message.content ?? []) {
-            if (b?.type === "text" && typeof b.text === "string")
-              collected2.push(b.text);
-          }
-          usage.add(rec);
-          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
-            stopReason = rec.message.stop_reason;
-          }
+        if (stopReason && Date.now() - stopSeenAt >= this.o.stopSettleMs) {
+          return { stopReason, end: "stop", denied: this.turnDenied };
+        }
+        if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
+        if (this.abandonTurn) return { stopReason: null, end: "interrupted", denied: this.turnDenied };
+        const now = Date.now();
+        if (onHeartbeat && now - lastBeat >= this.o.heartbeatMs) {
+          lastBeat = now;
+          if (now - this.lastDataAt < this.o.heartbeatMs) onHeartbeat();
         }
       }
-      this.cursor = lastComplete;
-      if (stopReason) break;
+      return { stopReason: null, end: null, denied: this.turnDenied };
+    } finally {
+      this.turn = null;
+      this.abandonTurn = false;
+      settle();
     }
+  }
+  /**
+   * Stop the running turn the way the TUI's own Esc does, and keep the
+   * session alive for the next one. Resolves true once the turn ended, false
+   * when it was abandoned after `interruptGraceMs` without the TUI saying so.
+   */
+  async interrupt(graceMs = this.o.interruptGraceMs) {
+    const turn = this.turn;
+    if (!turn) return true;
+    this.write("\x1B");
+    const ended = await Promise.race([turn.then(() => true), delay(graceMs).then(() => false)]);
+    if (ended) return true;
+    this.write("\x1B");
+    this.abandonTurn = true;
+    await Promise.race([turn, delay(this.o.pollMs * 4)]);
+    return false;
+  }
+  /**
+   * Inject a turn into the live session and return the assistant reply once a
+   * terminal stop_reason is observed in the transcript.
+   */
+  async ask(prompt, perTurnTimeoutMs) {
+    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
+    const t0 = Date.now();
+    const collected2 = [];
+    const usage = new TurnUsageAccumulator();
+    const { stopReason } = await this.runTurnLoop(
+      prompt,
+      (_raw, rec) => {
+        if (rec?.type !== "assistant" || !rec.message) return;
+        for (const b of rec.message.content ?? []) {
+          if (b?.type === "text" && typeof b.text === "string") collected2.push(b.text);
+        }
+        usage.add(rec);
+      },
+      timeout
+    );
     if (!stopReason) {
       throw new Error(
         this.failureMessage(
-          `turn timed out after ${timeout}ms (no terminal assistant record; collected ${collected2.length} text block(s))`
+          `turn ended without a terminal assistant record after ${Date.now() - t0}ms (collected ${collected2.length} text block(s))`
         )
       );
     }
@@ -8733,9 +9206,9 @@ var ClaudeSession = class {
   }
   /**
    * Like ask(), but instead of collecting the reply text it re-emits each NEW
-   * raw JSONL transcript line via onLine (verbatim) until a terminal
-   * stop_reason. Used by the opencode plugin transport shim, which feeds
-   * these raw lines into the existing stream-json line handler unchanged.
+   * raw JSONL transcript line via onLine (verbatim) until the turn ends. Used
+   * by the opencode plugin transport shim, which feeds these raw lines into
+   * the existing stream-json line handler unchanged.
    *
    * `usage` is the turn summed over DISTINCT API calls, which is exactly what
    * a headless `result` frame reports, so the shim can synthesize one and
@@ -8743,53 +9216,24 @@ var ClaudeSession = class {
    * `turnStats`) behaves as it does on the headless path. `lastCallUsage` is
    * the newest real call, returned because a caller with no stream parser
    * (`askOnce`) has no other way to get the context side.
+   *
+   * A turn that ends any way other than a terminal stop (an interrupt, a
+   * denied permission dialog, `turn_duration`) resolves with that `end` and a
+   * null `stopReason`; only a timeout throws.
    */
-  async tailTurn(prompt, onLine, perTurnTimeoutMs) {
-    if (this.aborted) throw new Error("aborted");
-    if (!this.proc || this.exited)
-      throw new Error("session not started or already exited");
+  async tailTurn(prompt, onLine, perTurnTimeoutMs, onHeartbeat) {
     const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
-    if (this.o.bracketedPaste) {
-      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
-    } else {
-      this.proc.terminal.write(prompt);
-    }
-    await this.submitTurn();
     const usage = new TurnUsageAccumulator();
-    let stopReason = null;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      await delay(this.o.pollMs);
-      if (this.aborted) throw new Error("aborted mid-turn");
-      const lines = this.readRawLines();
-      const lastComplete = lines.length - 1;
-      if (lastComplete <= this.cursor) {
-        if (this.exited) {
-          throw new Error(this.failureMessage("claude exited mid-turn", true));
-        }
-        continue;
-      }
-      for (let i = this.cursor; i < lastComplete; i++) {
-        const s = lines[i];
-        if (!s || !s.trim()) continue;
-        onLine(s);
-        let rec;
-        try {
-          rec = JSON.parse(s);
-        } catch {
-          continue;
-        }
-        usage.add(rec);
-        if (rec.type === "assistant" && rec.message) {
-          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
-            stopReason = rec.message.stop_reason;
-          }
-        }
-      }
-      this.cursor = lastComplete;
-      if (stopReason) break;
-    }
-    if (!stopReason) {
+    const { stopReason, end, denied } = await this.runTurnLoop(
+      prompt,
+      (raw, rec) => {
+        onLine(raw);
+        if (rec) usage.add(rec);
+      },
+      timeout,
+      onHeartbeat
+    );
+    if (!end) {
       throw new Error(
         this.failureMessage(
           `turn timed out after ${timeout}ms (no terminal assistant record)`
@@ -8798,26 +9242,32 @@ var ClaudeSession = class {
     }
     return {
       stopReason,
+      end,
       usage: usage.turnTotal,
       lastCallUsage: usage.lastCall,
-      callCount: usage.callCount
+      callCount: usage.callCount,
+      denied
     };
   }
-  dispose() {
-    if (this.proc) {
-      try {
-        this.proc.terminal.write("");
-      } catch {
-      }
-      try {
-        this.proc.kill();
-      } catch {
-      }
-      try {
-        this.proc.terminal.close();
-      } catch {
-      }
+  killProcess() {
+    const proc = this.proc;
+    if (!proc) return;
+    try {
+      proc.terminal.write("");
+    } catch {
+    }
+    try {
+      proc.kill();
+    } catch {
     }
+    try {
+      proc.terminal.close();
+    } catch {
+    }
+  }
+  dispose() {
+    this.clearScreenTimer();
+    this.killProcess();
     this.proc = null;
   }
 };
@@ -8891,9 +9341,88 @@ function interactiveExtraArgs(opts) {
   }
   return extraArgs;
 }
+var OpenToolCalls = class {
+  open = /* @__PURE__ */ new Map();
+  add(rec, now = Date.now()) {
+    const content = rec?.message?.content;
+    if (!Array.isArray(content)) return;
+    for (const block of content) {
+      if (rec.type === "assistant" && block?.type === "tool_use" && typeof block.id === "string") {
+        this.open.set(block.id, { name: String(block.name ?? "tool"), startedAt: now });
+      } else if (rec.type === "user" && block?.type === "tool_result") {
+        this.open.delete(block.tool_use_id);
+      }
+    }
+  }
+  newest() {
+    let newest = null;
+    for (const [id, call] of this.open) newest = { id, ...call };
+    return newest;
+  }
+  clear() {
+    this.open.clear();
+  }
+};
+function heartbeatFrame(sessionId, openCall, now = Date.now()) {
+  if (openCall) {
+    return JSON.stringify({
+      type: "tool_progress",
+      tool_use_id: `${openCall.id}-heartbeat`,
+      tool_name: openCall.name,
+      parent_tool_use_id: openCall.id,
+      heartbeat: true,
+      elapsed_time_seconds: Math.round((now - openCall.startedAt) / 1e3),
+      session_id: sessionId
+    });
+  }
+  return JSON.stringify({
+    type: "system",
+    subtype: "status",
+    status: "requesting",
+    session_id: sessionId
+  });
+}
+function interactiveResultFrame(opts) {
+  const completed = opts.end === "stop" && !!opts.stopReason;
+  let result;
+  let terminalReason = "completed";
+  if (!completed) {
+    if (opts.end === "failed") {
+      terminalReason = "error_during_execution";
+      result = `Interactive transport failed: ${opts.error ?? "unknown error"}`;
+    } else if (opts.end === "interrupted") {
+      terminalReason = "aborted";
+      result = "Interactive transport: the turn was interrupted.";
+    } else {
+      terminalReason = "error_during_execution";
+      result = "Interactive transport: the turn ended without a terminal stop_reason. Output above may be incomplete.";
+    }
+  }
+  return JSON.stringify({
+    type: "result",
+    subtype: completed ? "success" : "error_during_execution",
+    is_error: !completed,
+    stop_reason: completed ? opts.stopReason : null,
+    terminal_reason: terminalReason,
+    result,
+    session_id: opts.sessionId,
+    usage: opts.usage ?? {},
+    // The TUI has no `can_use_tool` channel, so a permission dialog is the
+    // only way it asks; each one the session denied is reported in the
+    // headless field's place, names and ids only (h #g109).
+    permission_denials: opts.denials ?? [],
+    total_cost_usd: null,
+    duration_ms: 0
+  });
+}
 function spawnInteractiveProcess(opts) {
   const extraArgs = interactiveExtraArgs(opts);
+  const openCalls = new OpenToolCalls();
+  let denials = [];
+  const lineEmitter = new EventEmitter4();
+  const proc = new EventEmitter4();
   const session = new ClaudeSession({
+    ...opts.tuning,
     cwd: opts.cwd,
     cliPath: opts.cliPath,
     configDir: opts.configDir,
@@ -8903,7 +9432,28 @@ function spawnInteractiveProcess(opts) {
     settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
     extraArgs,
     ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
-    effort: opts.effort ? cliEffortLevel(opts.effort) : void 0
+    effort: opts.effort ? cliEffortLevel(opts.effort) : void 0,
+    resumeSessionId: opts.resumeSessionId,
+    env: opts.env,
+    spawnPty: opts.spawnPty,
+    onScreen: (event) => {
+      if (event.action === "denied") {
+        const call = openCalls.newest();
+        denials.push(call ? { tool_name: call.name, tool_use_id: call.id } : { tool_name: "unknown" });
+      }
+      const data = { sessionId: session.sessionId, screen: event.kind, detail: event.detail };
+      if (event.action === "accepted") log.info("interactive transport accepted a prompt", data);
+      else if (event.action === "fatal") log.error("interactive transport cannot continue", data);
+      else if (event.action === "denied") log.warn("interactive transport denied a permission prompt", data);
+      else log.warn("interactive transport cancelled the usage-limit auto-continue", data);
+    },
+    onExit: (code) => {
+      proc.exitCode = code;
+      proc.signalCode = code === null ? "SIGTERM" : null;
+      log.info("interactive claude exited", { sessionId: session.sessionId, code });
+      proc.emit("exit", proc.exitCode, proc.signalCode);
+      proc.emit("close", proc.exitCode, proc.signalCode);
+    }
   });
   log.info("prepared interactive claude session", {
     cwd: opts.cwd,
@@ -8912,80 +9462,95 @@ function spawnInteractiveProcess(opts) {
     model: opts.model,
     effort: opts.effort,
     sessionId: session.sessionId,
+    resumed: !!opts.resumeSessionId,
     jsonlPath: session.jsonlPath
   });
-  const lineEmitter = new EventEmitter4();
-  const errorHandlers = /* @__PURE__ */ new Set();
   let startPromise = null;
   const ensureStarted = () => {
     if (!startPromise) startPromise = session.start();
     return startPromise;
   };
-  const emitResult = (opts2) => {
-    lineEmitter.emit(
-      "line",
-      JSON.stringify({
-        type: "result",
-        subtype: opts2.subtype,
-        is_error: opts2.isError,
-        stop_reason: opts2.stopReason,
-        terminal_reason: opts2.terminalReason,
-        result: opts2.result,
-        session_id: session.sessionId,
-        usage: opts2.usage ?? {},
-        total_cost_usd: null,
-        duration_ms: 0
-      })
-    );
-  };
-  const runTurn = (userMsg) => {
-    void (async () => {
-      try {
-        await ensureStarted();
-        const { stopReason, usage, lastCallUsage, callCount } = await session.tailTurn(userMsg, (raw) => {
-          lineEmitter.emit("line", raw);
-        });
-        log.info("interactive turn usage", {
-          apiCalls: callCount,
-          turnOutputTokens: usage?.output_tokens,
-          turnInputTokens: usage?.input_tokens,
-          turnCacheReadTokens: usage?.cache_read_input_tokens,
-          lastCallInputTokens: lastCallUsage?.input_tokens,
-          lastCallCacheReadTokens: lastCallUsage?.cache_read_input_tokens,
-          lastCallCacheWriteTokens: lastCallUsage?.cache_creation_input_tokens
-        });
-        const timedOut = !stopReason;
-        emitResult({
-          subtype: timedOut ? "error_during_execution" : "success",
-          isError: timedOut,
-          stopReason: timedOut ? null : stopReason,
-          terminalReason: timedOut ? "error_during_execution" : "completed",
-          result: timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
-          usage
-        });
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error(String(err));
-        log.error("interactive turn failed", { error: e.message });
-        emitResult({
-          subtype: "error_during_execution",
-          isError: true,
-          stopReason: null,
-          terminalReason: "error_during_execution",
-          result: `Interactive transport failed: ${e.message}`
-        });
-        if (errorHandlers.size > 0) {
-          for (const h of errorHandlers) h(e);
-        } else {
-          lineEmitter.emit("close");
-        }
+  let writes = 0;
+  let cancelledThrough = 0;
+  let queued = 0;
+  let chain = Promise.resolve();
+  const runTurn = async (userMsg, turnNumber) => {
+    const current = () => turnNumber === writes;
+    const emit2 = (line) => {
+      if (current()) lineEmitter.emit("line", line);
+    };
+    try {
+      await ensureStarted();
+      if (turnNumber <= cancelledThrough) {
+        log.info("interactive turn cancelled before it started", { sessionId: session.sessionId });
+        return;
       }
-    })();
+      openCalls.clear();
+      denials = [];
+      const { stopReason, end, usage, lastCallUsage, callCount, denied } = await session.tailTurn(
+        userMsg,
+        (raw) => {
+          try {
+            openCalls.add(JSON.parse(raw));
+          } catch {
+          }
+          emit2(raw);
+        },
+        void 0,
+        () => emit2(heartbeatFrame(session.sessionId, openCalls.newest()))
+      );
+      log.info("interactive turn ended", {
+        end,
+        stopReason,
+        superseded: !current(),
+        apiCalls: callCount,
+        turnOutputTokens: usage?.output_tokens,
+        turnInputTokens: usage?.input_tokens,
+        turnCacheReadTokens: usage?.cache_read_input_tokens,
+        lastCallInputTokens: lastCallUsage?.input_tokens,
+        lastCallCacheReadTokens: lastCallUsage?.cache_read_input_tokens,
+        lastCallCacheWriteTokens: lastCallUsage?.cache_creation_input_tokens,
+        deniedPrompts: denied.length,
+        cancelled: turnNumber <= cancelledThrough
+      });
+      emit2(
+        interactiveResultFrame({
+          sessionId: session.sessionId,
+          end,
+          stopReason,
+          usage,
+          denials
+        })
+      );
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      log.error("interactive turn failed", { error: e.message, superseded: !current() });
+      if (!current()) return;
+      emit2(
+        interactiveResultFrame({
+          sessionId: existsSync4(session.jsonlPath) ? session.sessionId : void 0,
+          end: "failed",
+          stopReason: null,
+          error: e.message
+        })
+      );
+      if (proc.listenerCount("error") > 0) proc.emit("error", e);
+      else lineEmitter.emit("close");
+    }
+  };
+  const enqueueTurn = (userMsg) => {
+    const turnNumber = ++writes;
+    queued++;
+    chain = chain.then(() => runTurn(userMsg, turnNumber)).finally(() => {
+      queued--;
+    });
   };
-  const proc = {
+  Object.assign(proc, {
     stdin: {
+      writable: true,
       write(chunk) {
         const raw = typeof chunk === "string" && chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
-        runTurn(decodeUserEnvelope(raw));
+        enqueueTurn(decodeUserEnvelope(raw));
         return true;
       },
       end() {
@@ -8995,47 +9560,56 @@ function spawnInteractiveProcess(opts) {
     stderr: null,
     pid: -1,
     killed: false,
-    on(event, fn) {
-      if (event === "error") errorHandlers.add(fn);
-      return proc;
-    },
-    once() {
-      return proc;
-    },
-    off(event, fn) {
-      if (event === "error") errorHandlers.delete(fn);
-      return proc;
-    },
+    exitCode: null,
+    signalCode: null,
     kill() {
+      if (!proc.killed) {
+        proc.killed = true;
+        if (opts.systemPromptFile) {
+          void unlink2(opts.systemPromptFile).catch(() => {
+          });
+        }
+      }
+      const started = startPromise !== null;
       try {
         session.dispose();
       } catch {
       }
-      if (opts.systemPromptFile) {
-        void unlink2(opts.systemPromptFile).catch(() => {
-        });
+      if (!started && proc.exitCode === null && proc.signalCode === null) {
+        proc.signalCode = "SIGTERM";
+        proc.emit("exit", null, "SIGTERM");
+        proc.emit("close", null, "SIGTERM");
       }
-      proc.killed = true;
       return true;
     }
-  };
+  });
   return {
     proc,
     lineEmitter,
     proxyServer: null,
     mcpHash: void 0,
-    systemPromptFile: opts.systemPromptFile
+    systemPromptFile: opts.systemPromptFile,
+    cliPath: opts.cliPath,
+    interactiveControl: {
+      turnRunning: () => queued > 0,
+      // Stops the running turn and every queued one: they were all written
+      // by the turn being aborted, or by one before it.
+      interrupt: (timeoutMs) => {
+        cancelledThrough = writes;
+        return session.interrupt(timeoutMs);
+      }
+    }
   };
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir7 } from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir8 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname6, join as join10 } from "path";
 function readPromptFileIfPresent(path11) {
   try {
-    const content = readFileSync6(path11, "utf8").trim();
+    const content = readFileSync7(path11, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -9044,7 +9618,7 @@ function readPromptFileIfPresent(path11) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join9(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join10(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -9153,8 +9727,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join9(homedir7(), ".config");
-  const globalAgents = readPromptFileIfPresent(join9(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join10(homedir8(), ".config");
+  const globalAgents = readPromptFileIfPresent(join10(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -9165,9 +9739,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path11 = join9(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path11 = join10(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    writeFileSync4(path11, content, { encoding: "utf8", mode: 384 });
+    writeFileSync5(path11, content, { encoding: "utf8", mode: 384 });
     return path11;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -9885,8 +10459,8 @@ function synthesizeTitle(prompt) {
     "summary",
     "project"
   ]);
-  const words = source.split(" ").map((word) => word.trim()).filter(Boolean).filter((word) => !stop.has(word.toLowerCase()));
-  const picked = (words.length > 0 ? words : source.split(" ").filter(Boolean)).slice(0, 6).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  const words2 = source.split(" ").map((word) => word.trim()).filter(Boolean).filter((word) => !stop.has(word.toLowerCase()));
+  const picked = (words2.length > 0 ? words2 : source.split(" ").filter(Boolean)).slice(0, 6).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
   return picked || "New Session";
 }
 
@@ -10350,6 +10924,11 @@ function clearStartWatchdog(state) {
 function onStartWatchdogFire(state) {
   state.startWatchdog = null;
   if (state.controllerClosed || state.hasReceivedContent || state.hasReceivedProgress) return;
+  const interactive = state.activeProcess?.interactiveControl;
+  if (interactive) {
+    if (interactive.turnRunning()) armStartWatchdog(state);
+    return;
+  }
   if (state.respawnAttempted) {
     log.error(
       "claude process still silent after respawn; ending turn",
@@ -12170,6 +12749,23 @@ var ClaudeCodeLanguageModel = class {
         }
       }
     }
+    if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
+      const configDir = resolveConfigDir(this.config.configDir);
+      const resumePoint = findResumePoint({
+        sessionKey: sk,
+        prompt: options.prompt,
+        cliPath,
+        transcriptPath: (id) => join11(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`)
+      });
+      if (resumePoint) {
+        setClaudeSessionId(sk, resumePoint.claudeSessionId);
+        includeHistoryContext = false;
+        log.notice("resuming the claude session from before the restart instead of replaying it", {
+          sessionKey: sk,
+          matchedMessages: resumePoint.matched
+        });
+      }
+    }
     if (this.config.forkSessions === true && !compactionMode && !useInteractive) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
@@ -12463,6 +13059,7 @@ var ClaudeCodeLanguageModel = class {
                 ...self.skillBridgeSpawn(failover)
               });
               if (stoppedBeforeWork()) return;
+              const resumeSessionId = getClaudeSessionId(sk);
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -12474,8 +13071,20 @@ var ClaudeCodeLanguageModel = class {
                 permissionsAllow: allow,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
-                effort: reasoningEffort
+                effort: reasoningEffort,
+                resumeSessionId,
+                // The headless spawn's env, so hygiene, effort and the
+                // agent's prompt cache TTL reach both transports alike.
+                env: claudeSpawnEnv({
+                  ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
+                  effort: reasoningEffort,
+                  promptCacheTtl
+                })
               });
+              ap.proc.once(
+                "exit",
+                (code) => noteInteractiveProcessExit(sk, ap, code)
+              );
               ap.mcpHash = mcp.bridgedHash;
               ap.mcpServers = mcp.allEnabledServerNames;
               setActiveProcess(sk, ap);
@@ -12484,6 +13093,7 @@ var ClaudeCodeLanguageModel = class {
               state.activeProcess = ap;
               log.info("spawned interactive claude session", {
                 sk,
+                resumed: !!resumeSessionId,
                 cliPath,
                 configDir: self.config.configDir,
                 model: effectiveModelId
@@ -12723,6 +13333,9 @@ var ClaudeCodeLanguageModel = class {
           state.autoContinueState.startedAt = Date.now();
           const completeResult = (msg) => {
             if (state.controllerClosed) return;
+            if (self.config.resumeAfterRestart !== false && !compactionMode && msg.is_error !== true && typeof msg.session_id === "string") {
+              recordResumePoint(sk, msg.session_id, options.prompt, cliPath);
+            }
             if (deliverPendingCompletions(state)) {
               if (state.drainBuffer.length > 0) drainNow(state);
               return;
@@ -13179,15 +13792,15 @@ var ClaudeCodeLanguageModel = class {
 
 // src/cleanup-stale.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname7, join as join10, resolve as resolve5 } from "path";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname7, join as join12, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -13195,20 +13808,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join10(xdg, "opencode") : null,
-    join10(homedir8(), ".cache", "opencode"),
-    join10(homedir8(), "Library", "Caches", "opencode")
+    xdg ? join12(xdg, "opencode") : null,
+    join12(homedir9(), ".cache", "opencode"),
+    join12(homedir9(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join10(homedir8(), ".config");
-  return join10(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join12(homedir9(), ".config");
+  return join12(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
-  if (!existsSync3(cfg)) return false;
+  if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync7(cfg, "utf8"));
+    const json = JSON.parse(readFileSync8(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -13229,19 +13842,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync7(join10(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join12(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join10(homedir8(), ".local", "state");
-  return join10(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join12(homedir9(), ".local", "state");
+  return join12(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync7(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync8(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -13250,8 +13863,8 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync4(dirname7(file), { recursive: true });
-    writeFileSync5(
+    mkdirSync5(dirname7(file), { recursive: true });
+    writeFileSync6(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -13285,20 +13898,20 @@ function cleanupStaleUnscopedInstall() {
   if (version) writeMarker(version);
 }
 function cleanupOne(cacheRoot, ourDir) {
-  if (!existsSync3(cacheRoot)) return;
-  const stalePath = join10(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
-  if (!existsSync3(stalePath)) return;
+  if (!existsSync5(cacheRoot)) return;
+  const stalePath = join12(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
     realStalePath = realpathSync4(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join10(stalePath, "package.json");
-  if (!existsSync3(pkgJsonPath)) return;
+  const pkgJsonPath = join12(stalePath, "package.json");
+  if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync7(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync8(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -13314,13 +13927,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join10(cacheRoot, "package.json");
-  if (!existsSync3(cachePkgJson)) return;
+  const cachePkgJson = join12(cacheRoot, "package.json");
+  if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync7(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync8(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync5(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync6(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -13981,6 +14594,7 @@ function createClaudeCode(settings = {}) {
       bridgeSkipNativeSkills: settings.bridgeSkipNativeSkills !== false,
       turnStats: settings.turnStats === true,
       forkSessions: settings.forkSessions === true,
+      resumeAfterRestart: settings.resumeAfterRestart !== false,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
       interactiveAllowTools: settings.interactiveAllowTools,
@@ -14066,12 +14680,12 @@ function configModelsForProvider(providerModels, providerID, modelSuffix) {
   }
   return models;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function completeUserModel(id, entry, providerID) {
-  const record = isRecord4(entry) ? entry : {};
-  const runtimeShaped = isRecord4(record.capabilities) && isRecord4(record.capabilities.input) && isRecord4(record.capabilities.output) && isRecord4(record.cost) && isRecord4(record.cost.cache) && isRecord4(record.api);
+  const record = isRecord5(entry) ? entry : {};
+  const runtimeShaped = isRecord5(record.capabilities) && isRecord5(record.capabilities.input) && isRecord5(record.capabilities.output) && isRecord5(record.cost) && isRecord5(record.cost.cache) && isRecord5(record.api);
   if (runtimeShaped) {
     return toConfigModel({ ...record, providerID });
   }
@@ -14084,8 +14698,8 @@ function completeUserModel(id, entry, providerID) {
   const merged = { ...base, ...record, id };
   for (const key of ["cost", "limit", "variants"]) {
     merged[key] = {
-      ...isRecord4(base[key]) ? base[key] : {},
-      ...isRecord4(record[key]) ? record[key] : {}
+      ...isRecord5(base[key]) ? base[key] : {},
+      ...isRecord5(record[key]) ? record[key] : {}
     };
   }
   return merged;
@@ -14182,7 +14796,7 @@ async function buildAgentRegistry(config) {
     typeof configuredTtl === "string" ? configuredTtl : void 0
   );
   setProviderFallbackModels(parseFallbackModelList(options?.fallbackModels));
-  const records = await readAgentMarkdownRecords(
+  const records2 = await readAgentMarkdownRecords(
     agentDirectories(
       process.env.HOME ?? process.env.USERPROFILE,
       getOpencodeProjectDirectory()
@@ -14197,18 +14811,18 @@ async function buildAgentRegistry(config) {
     const declaredChain = parseFallbackModelList(
       agent.fallbackModels ?? bag.fallbackModels
     );
-    records[name] = {
-      mode: pick("mode") ?? records[name]?.mode,
-      model: pick("model") ?? records[name]?.model,
-      forceModel: pick("forceModel") ?? records[name]?.forceModel,
-      reasoningEffort: pick("reasoningEffort") ?? records[name]?.reasoningEffort,
-      cacheTtl: pick("cacheTtl") ?? records[name]?.cacheTtl,
-      fallbackModels: declaredChain.length ? declaredChain : records[name]?.fallbackModels
+    records2[name] = {
+      mode: pick("mode") ?? records2[name]?.mode,
+      model: pick("model") ?? records2[name]?.model,
+      forceModel: pick("forceModel") ?? records2[name]?.forceModel,
+      reasoningEffort: pick("reasoningEffort") ?? records2[name]?.reasoningEffort,
+      cacheTtl: pick("cacheTtl") ?? records2[name]?.cacheTtl,
+      fallbackModels: declaredChain.length ? declaredChain : records2[name]?.fallbackModels
     };
   }
-  setAgentRegistry(records);
+  setAgentRegistry(records2);
   log.debug("agent registry built", {
-    agents: Object.keys(records).length,
+    agents: Object.keys(records2).length,
     defaultSubagentModel: getDefaultSubagentModel()
   });
 }