@khalilgharbaoui/opencode-claude-code-plugin 0.45.0 → 0.46.1

package/dist/index.js

@@ -916,6 +916,10 @@ function formatResultFailureNote(message) {
 ${RESULT_ERROR_MARKER} ${message}
 `;
 }
+function formatCompactionFailure(cause, detail) {
+  const said = detail?.trim();
+  return `Claude Code could not compact this conversation (${cause}), so no summary was produced.` + (said ? ` The CLI said: ${said}` : "");
+}
 var STREAM_TIMEOUT_MARKER = "\u258C **stream timeout:**";
 function formatStreamTimeoutNote(silenceMs) {
   const seconds = Math.max(1, Math.round(silenceMs / 1e3));
@@ -1621,7 +1625,108 @@ function failoverUntil(resetsAt) {
 // src/cli-version.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
+
+// src/windows-spawn.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+function envValue(env, name) {
+  const direct = env[name];
+  if (direct !== void 0) return direct;
+  const match = Object.keys(env).find((key) => key.toLowerCase() === name.toLowerCase());
+  return match === void 0 ? void 0 : env[match];
+}
+function defaultIsFile(candidate) {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function executableExtensions(env = process.env) {
+  const raw = envValue(env, "PATHEXT") ?? DEFAULT_PATHEXT;
+  return raw.split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean).map((ext) => ext.startsWith(".") ? ext : `.${ext}`);
+}
+function isBatchFile(file) {
+  const ext = path2.win32.extname(file).toLowerCase();
+  return ext === ".cmd" || ext === ".bat";
+}
+function resolveWindowsCommand(command, deps = {}) {
+  const env = deps.env ?? process.env;
+  const isFile = deps.isFile ?? defaultIsFile;
+  const extensions = executableExtensions(env);
+  const candidatesFor = (base) => {
+    const ext = path2.win32.extname(base).toLowerCase();
+    if (ext && extensions.includes(ext)) return [base];
+    return [...extensions.map((candidate) => base + candidate), base];
+  };
+  if (command.includes("\\") || command.includes("/")) {
+    for (const candidate of candidatesFor(command)) {
+      if (isFile(candidate)) return candidate;
+    }
+    return null;
+  }
+  const pathValue = envValue(env, "PATH") ?? "";
+  for (const entry of pathValue.split(path2.win32.delimiter)) {
+    const directory = entry.trim().replace(/^"(.*)"$/, "$1");
+    if (!directory) continue;
+    for (const candidate of candidatesFor(path2.win32.join(directory, command))) {
+      if (isFile(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function quoteBatchArgument(arg) {
+  if (/[\r\n]/.test(arg)) {
+    throw new Error("cmd.exe cannot carry a newline in an argument");
+  }
+  let out = '"';
+  let backslashes = 0;
+  for (const char of arg) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      out += "\\".repeat(backslashes * 2) + '""';
+      backslashes = 0;
+      continue;
+    }
+    out += "\\".repeat(backslashes) + char;
+    backslashes = 0;
+  }
+  return `${out}${"\\".repeat(backslashes * 2)}"`;
+}
+function planCmdInvocation(file, args, env = process.env) {
+  const comspec = envValue(env, "ComSpec") ?? "cmd.exe";
+  const line = [`"${path2.win32.normalize(file)}"`, ...args.map(quoteBatchArgument)];
+  return {
+    file: comspec,
+    args: ["/d", "/s", "/c", `"${line.join(" ")}"`],
+    windowsVerbatimArguments: true
+  };
+}
+function planClaudeSpawn(command, args, deps = {}) {
+  const platform2 = deps.platform ?? process.platform;
+  if (platform2 !== "win32") return { file: command, args: [...args] };
+  const env = deps.env ?? process.env;
+  const resolved = resolveWindowsCommand(command, deps) ?? command;
+  if (isBatchFile(resolved)) return planCmdInvocation(resolved, args, env);
+  return { file: resolved, args: [...args] };
+}
+
+// src/cli-version.ts
 var execFileAsync = promisify(execFile);
+function probeExec(cliPath, args, options) {
+  const plan = planClaudeSpawn(cliPath, args);
+  return execFileAsync(plan.file, plan.args, {
+    ...options,
+    // utf8 is already `execFile`'s default; naming it is what keeps the
+    // promisified overload returning strings rather than Buffers.
+    encoding: "utf8",
+    windowsVerbatimArguments: plan.windowsVerbatimArguments
+  });
+}
 var cache = /* @__PURE__ */ new Map();
 var PROBE_TIMEOUT_MS = 5e3;
 var probeTimeoutMs = PROBE_TIMEOUT_MS;
@@ -1668,7 +1773,7 @@ function detectCliVersion(cliPath) {
   let deadlineKill = false;
   const promise = (async () => {
     try {
-      const { stdout } = await execFileAsync(cliPath, ["--version"], {
+      const { stdout } = await probeExec(cliPath, ["--version"], {
         timeout: probeTimeoutMs
       });
       const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout.trim());
@@ -1765,7 +1870,7 @@ function detectHeadlessSupport(cliPath) {
   let deadlineKill = false;
   const promise = (async () => {
     try {
-      const execution = execFileAsync(cliPath, [
+      const execution = probeExec(cliPath, [
         "--print",
         "--input-format",
         "stream-json",
@@ -1801,7 +1906,7 @@ function detectCliSupportsFlag(cliPath, flag) {
   let deadlineKill = false;
   const promise = (async () => {
     try {
-      const execution = execFileAsync(cliPath, ["--help"], {
+      const execution = probeExec(cliPath, ["--help"], {
         timeout: probeTimeoutMs,
         killSignal: "SIGKILL",
         maxBuffer: 4 * 1024 * 1024
@@ -1834,17 +1939,17 @@ import { unlink } from "fs/promises";
 
 // src/proxy-mcp.ts
 import { createServer } from "http";
-import * as fs2 from "fs";
-import * as path3 from "path";
+import * as fs3 from "fs";
+import * as path4 from "path";
 import * as crypto from "crypto";
 import { EventEmitter } from "events";
 
 // src/tmp.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as os from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 var PLUGIN_TMP_PREFIX = "opencode-claude-code-";
-var PID_TMP_DIR = path2.join(
+var PID_TMP_DIR = path3.join(
   os.tmpdir(),
   `${PLUGIN_TMP_PREFIX}${process.pid}`
 );
@@ -1857,7 +1962,7 @@ function currentUid() {
 function untrustworthyReason(dir) {
   let stat;
   try {
-    stat = fs.lstatSync(dir);
+    stat = fs2.lstatSync(dir);
   } catch {
     return null;
   }
@@ -1870,16 +1975,16 @@ function untrustworthyReason(dir) {
   return null;
 }
 function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
   try {
-    fs.chmodSync(dir, 448);
+    fs2.chmodSync(dir, 448);
   } catch {
   }
 }
 function chooseDir() {
   const reason = untrustworthyReason(PID_TMP_DIR);
   if (!reason) return PID_TMP_DIR;
-  const fallback = fs.mkdtempSync(path2.join(os.tmpdir(), PLUGIN_TMP_PREFIX));
+  const fallback = fs2.mkdtempSync(path3.join(os.tmpdir(), PLUGIN_TMP_PREFIX));
   log.warn("refusing the pid-named scratch directory", {
     path: PID_TMP_DIR,
     reason,
@@ -1893,7 +1998,7 @@ function registerExitCleanup() {
   process.on("exit", () => {
     for (const dir of createdDirs) {
       try {
-        fs.rmSync(dir, { recursive: true, force: true });
+        fs2.rmSync(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -1914,23 +2019,23 @@ function sweepStalePluginTmpDirs(keep) {
   const root = os.tmpdir();
   let entries;
   try {
-    entries = fs.readdirSync(root);
+    entries = fs2.readdirSync(root);
   } catch {
     return removed;
   }
   const uid = currentUid();
-  const keepPath = keep ? path2.resolve(keep) : null;
+  const keepPath = keep ? path3.resolve(keep) : null;
   for (const entry of entries) {
     const match = PID_DIR_NAME.exec(entry);
     if (!match) continue;
     const pid = Number(match[1]);
     if (!Number.isSafeInteger(pid) || pid <= 0) continue;
     if (pid === process.pid) continue;
-    const dir = path2.join(root, entry);
-    if (keepPath && path2.resolve(dir) === keepPath) continue;
+    const dir = path3.join(root, entry);
+    if (keepPath && path3.resolve(dir) === keepPath) continue;
     let stat;
     try {
-      stat = fs.lstatSync(dir);
+      stat = fs2.lstatSync(dir);
     } catch {
       continue;
     }
@@ -1938,7 +2043,7 @@ function sweepStalePluginTmpDirs(keep) {
     if (uid !== void 0 && stat.uid !== uid) continue;
     if (isProcessAlive(pid)) continue;
     try {
-      fs.rmSync(dir, { recursive: true, force: true });
+      fs2.rmSync(dir, { recursive: true, force: true });
       removed.push(dir);
     } catch (err) {
       log.debug("could not remove a stale scratch directory", {
@@ -2769,11 +2874,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         2
       );
       const hash = crypto.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path3.join(
+      const outPath = path4.join(
         pluginTmpDir(),
         `proxy-${hash}.json`
       );
-      fs2.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
       configFilePath = outPath;
       return outPath;
     },
@@ -2790,7 +2895,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       });
       if (configFilePath) {
         try {
-          fs2.unlinkSync(configFilePath);
+          fs3.unlinkSync(configFilePath);
         } catch {
         }
         configFilePath = null;
@@ -3359,8 +3464,8 @@ function clearCompression(sessionKey2) {
 }
 
 // src/mcp-bridge.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path5 from "path";
 import * as os2 from "os";
 import * as crypto2 from "crypto";
 import {
@@ -3371,21 +3476,21 @@ var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
 var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
 function fileExists(p) {
   try {
-    return fs3.statSync(p).isFile();
+    return fs4.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function dirExists(p) {
   try {
-    return fs3.statSync(p).isDirectory();
+    return fs4.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function readAndParse(file) {
   try {
-    const raw = fs3.readFileSync(file, "utf8");
+    const raw = fs4.readFileSync(file, "utf8");
     const errors = [];
     const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
     if (errors.length > 0) {
@@ -3421,14 +3526,14 @@ function deepMerge(target, source) {
 }
 function walkUp(opts) {
   const out = [];
-  let current = path4.resolve(opts.start);
+  let current = path5.resolve(opts.start);
   while (true) {
     for (const target of opts.targets) {
-      const candidate = path4.join(current, target);
+      const candidate = path5.join(current, target);
       if (opts.predicate(candidate)) out.push(candidate);
     }
-    if (opts.stop && current === path4.resolve(opts.stop)) break;
-    const parent = path4.dirname(current);
+    if (opts.stop && current === path5.resolve(opts.stop)) break;
+    const parent = path5.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -3436,28 +3541,28 @@ function walkUp(opts) {
 }
 function detectWorktree(cwd) {
   const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path4.resolve(override);
-  let current = path4.resolve(cwd);
+  if (override) return path5.resolve(override);
+  let current = path5.resolve(cwd);
   while (true) {
-    const gitPath = path4.join(current, ".git");
+    const gitPath = path5.join(current, ".git");
     try {
-      if (fs3.existsSync(gitPath)) return current;
+      if (fs4.existsSync(gitPath)) return current;
     } catch {
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
 }
 function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path4.join(os2.homedir(), ".config");
-  return path4.join(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME ?? path5.join(os2.homedir(), ".config");
+  return path5.join(xdg, "opencode");
 }
 function loadGlobalConfig(hostApi = "v1") {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path4.join(dir, name);
+    const file = path5.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
@@ -3467,7 +3572,7 @@ function loadGlobalConfig(hostApi = "v1") {
 function loadProjectFilesInDir(dir, hostApi = "v1") {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path4.join(dir, name);
+    const file = path5.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
@@ -3478,7 +3583,7 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path4.resolve(p);
+    const abs = path5.resolve(p);
     if (!seen.has(abs) && dirExists(abs)) {
       seen.add(abs);
       dirs.push(abs);
@@ -3494,7 +3599,7 @@ function dotOpencodeDirs(cwd, worktree) {
   }
   const home = os2.homedir();
   if (home) {
-    const homeDot = path4.join(home, ".opencode");
+    const homeDot = path5.join(home, ".opencode");
     if (dirExists(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
@@ -3641,7 +3746,7 @@ function opencodeConfigLayers(cwd, hostApi = "v1") {
   const projectDirs = [];
   const seenProjectDirs = /* @__PURE__ */ new Set();
   for (const f of projectFiles) {
-    const d = path4.dirname(f);
+    const d = path5.dirname(f);
     if (!seenProjectDirs.has(d)) {
       seenProjectDirs.add(d);
       projectDirs.push(d);
@@ -3708,13 +3813,13 @@ function finishBridge(input) {
   }
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
   const bodyDigest = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-  const outPath = path4.join(
+  const outPath = path5.join(
     pluginTmpDir(),
     `mcp-${bodyDigest}.json`
   );
   try {
     if (!fileExists(outPath)) {
-      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs4.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
     }
   } catch (e) {
     log.warn("failed to write bridged MCP config", {
@@ -4250,7 +4355,8 @@ function messageDigest(msg) {
   }
   return hash.digest("hex").slice(0, 32);
 }
-function conversationDigests(prompt) {
+var ASSISTANT_TURN_DIGEST = "assistant-turn";
+function conversationDigests(prompt, opts) {
   const out = [];
   for (const msg of prompt) {
     if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") {
@@ -4258,7 +4364,7 @@ function conversationDigests(prompt) {
     }
     out.push({
       role: msg.role,
-      digest: messageDigest(msg)
+      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg)
     });
   }
   return out;
@@ -4285,7 +4391,24 @@ function forkSiblingSignature(sessionKey2) {
   blanked[3] = "*";
   return blanked.join("::");
 }
-function splitForkHistory(prompt) {
+function modelSiblingSignature(sessionKey2) {
+  const parts = sessionKey2.split("::");
+  if (parts.length < 5) return null;
+  if (parts[2] === "compaction") return null;
+  const withoutEffort = parts[parts.length - 1].startsWith("effort=") ? parts.slice(0, -1) : parts;
+  if (withoutEffort.length < 5) return null;
+  const blanked = [...withoutEffort];
+  blanked[1] = "*";
+  return blanked.join("::");
+}
+function moveForkFingerprint(fromKey, toKey) {
+  const record = fingerprints.get(fromKey);
+  if (!record) return;
+  fingerprints.delete(fromKey);
+  fingerprints.delete(toKey);
+  fingerprints.set(toKey, { ...record, seq: ++fingerprintSeq });
+}
+function splitForkHistory(prompt, opts) {
   const messages = prompt;
   let lastAssistant = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -4304,7 +4427,7 @@ function splitForkHistory(prompt) {
     }
   }
   return {
-    history: conversationDigests(messages.slice(0, lastAssistant + 1)),
+    history: conversationDigests(messages.slice(0, lastAssistant + 1), opts),
     forkable: true
   };
 }
@@ -4343,8 +4466,8 @@ function findForkParent(opts) {
   }
   return best;
 }
-function continuesRecordedConversation(recorded, prompt) {
-  const { history, forkable } = splitForkHistory(prompt);
+function continuesRecordedConversation(recorded, prompt, opts) {
+  const { history, forkable } = splitForkHistory(prompt, opts);
   if (!forkable || recorded.length === 0 || recorded.length > history.length) return false;
   return isPrefix(recorded, history) && tailIsReplyOnly(history, recorded.length);
 }
@@ -4381,7 +4504,7 @@ function isDigest(value) {
 }
 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);
+  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest) && (record.shape === void 0 || Array.isArray(record.shape) && record.shape.every(isDigest));
 }
 function load() {
   if (records) return records;
@@ -4430,13 +4553,14 @@ function save(update) {
 function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath) {
   const chain = conversationDigests(prompt);
   if (chain.length === 0) return;
+  const shape2 = conversationDigests(prompt, { assistantContent: false });
   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)) {
+  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && 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() });
+    merged.set(sessionKey2, { claudeSessionId, cliPath, chain, shape: shape2, updatedAt: Date.now() });
   });
 }
 function forgetResumePoint(sessionKey2) {
@@ -4445,25 +4569,84 @@ function forgetResumePoint(sessionKey2) {
     merged.delete(sessionKey2);
   });
 }
+function moveResumePoint(fromKey, toKey) {
+  const record = load().get(fromKey);
+  if (!record) return;
+  save((merged) => {
+    merged.delete(fromKey);
+    if (merged.has(toKey)) return;
+    merged.set(toKey, { ...record, updatedAt: Date.now() });
+  });
+}
 function findResumePoint(opts) {
   const record = load().get(opts.sessionKey);
-  if (!record) return void 0;
+  if (!record) {
+    opts.onRefused?.("no-session-recorded");
+    return void 0;
+  }
   const refuse = (reason) => {
     log.info("not resuming the claude session from before the restart", {
       sessionKey: opts.sessionKey,
       reason
     });
+    opts.onRefused?.(reason);
     return void 0;
   };
-  if (record.cliPath !== opts.cliPath) return refuse("another claude binary");
+  if (record.cliPath !== opts.cliPath) return refuse("another-claude-binary");
   if (!continuesRecordedConversation(record.chain, opts.prompt)) {
-    return refuse("the conversation changed");
+    return refuse("conversation-changed");
   }
   if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
-    return refuse("the transcript is gone");
+    return refuse("transcript-gone");
   }
   return { claudeSessionId: record.claudeSessionId, matched: record.chain.length };
 }
+function findSiblingResumePoint(opts) {
+  const signature = modelSiblingSignature(opts.sessionKey);
+  if (!signature) {
+    opts.onRefused?.("no-sibling-possible");
+    return void 0;
+  }
+  let best;
+  let bestUpdatedAt = -1;
+  let refusal;
+  for (const [key, record] of load()) {
+    if (key === opts.sessionKey) continue;
+    if (modelSiblingSignature(key) !== signature) continue;
+    if (record.cliPath !== opts.cliPath) {
+      refusal = "sibling-another-claude-binary";
+      continue;
+    }
+    if (!record.shape || !continuesRecordedConversation(record.shape, opts.prompt, {
+      assistantContent: false
+    })) {
+      refusal = "sibling-conversation-changed";
+      continue;
+    }
+    if (opts.isBusy(key)) {
+      refusal = "sibling-still-writing";
+      continue;
+    }
+    if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
+      refusal = "sibling-transcript-gone";
+      continue;
+    }
+    if (record.updatedAt >= bestUpdatedAt) {
+      bestUpdatedAt = record.updatedAt;
+      best = {
+        claudeSessionId: record.claudeSessionId,
+        siblingKey: key,
+        matched: record.chain.length
+      };
+    }
+  }
+  if (!best) {
+    opts.onRefused?.(
+      refusal ?? "no-sibling-recorded"
+    );
+  }
+  return best;
+}
 
 // src/permission-presets.ts
 var READ_ONLY_DISALLOWED_CLI_TOOLS = [
@@ -5164,6 +5347,23 @@ function deleteClaudeSessionId(key) {
   forgetForkFingerprint(key);
   forgetResumePoint(key);
 }
+function transferClaudeSession(fromKey, toKey) {
+  if (fromKey === toKey) return void 0;
+  const claudeSessionId = claudeSessions.get(fromKey);
+  if (!claudeSessionId) return void 0;
+  if (claudeSessions.has(toKey)) return void 0;
+  claudeSessions.delete(fromKey);
+  setClaudeSessionId(toKey, claudeSessionId);
+  moveResumePoint(fromKey, toKey);
+  moveForkFingerprint(fromKey, toKey);
+  clearExitPlanModeQuestions(fromKey);
+  clearAccountFailoverQuestions(fromKey);
+  log.notice("carrying the claude conversation over to the new session key", {
+    fromKey,
+    toKey
+  });
+  return claudeSessionId;
+}
 function effortSessionKey(baseKey, effort) {
   return effort ? `${baseKey}::effort=${effort}` : baseKey;
 }
@@ -5186,8 +5386,14 @@ function invalidateOtherEffortSessions(baseKey, effort) {
       );
     }
   }
+  const currentKey = effortSessionKey(baseKey, effort);
   for (const key of staleKeys) {
     deleteActiveProcess(key);
+    if (transferClaudeSession(key, currentKey)) {
+      clearCompression(key);
+      clearBackgroundTasks(key);
+      continue;
+    }
     deleteClaudeSessionId(key);
     clearCompression(key);
     clearBackgroundTasks(key);
@@ -5203,11 +5409,12 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     effort,
     promptCacheTtl
   });
-  const proc = spawn(cliPath, cliArgs, {
+  const plan = planClaudeSpawn(cliPath, cliArgs);
+  const proc = spawn(plan.file, plan.args, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
     env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl }),
-    shell: process.platform === "win32"
+    windowsVerbatimArguments: plan.windowsVerbatimArguments
   });
   const lineEmitter = new EventEmitter3();
   const ap = {
@@ -5270,12 +5477,11 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
       }
     }
     if (ownsSessionKey && code !== 0 && code !== null) {
-      log.info("process exited with error, clearing session", {
+      log.info("process exited with error; keeping the claude session to resume", {
         code,
-        sessionKey: sessionKey2
+        sessionKey: sessionKey2,
+        resumable: claudeSessions.has(sessionKey2)
       });
-      claudeSessions.delete(sessionKey2);
-      forgetResumePoint(sessionKey2);
     }
   });
   proc.stderr?.on("data", (data) => {
@@ -5788,6 +5994,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "btw: a turn is running but no claude process appeared for it",
   "btw: early aside failed; the message will ask again",
   "cannot interrupt this transport; waiting for the turn to end",
+  "carrying the claude conversation over to the new session key",
   "claude --version output unparseable",
   "claude account is out of usage; the turn ends with a note",
   "claude already registers a different skill under this name; not bridging ours",
@@ -5795,6 +6002,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
   "claude code compacted its own context",
   "claude code reset its conversation",
+  "claude could not compact the conversation; no summary was stored",
   "claude finished the turn without a reply",
   "claude kept missing the probe deadline; keeping the conservative answer for this process",
   "claude process belongs to another account; starting fresh",
@@ -5810,6 +6018,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "cleanup-stale: could not record the sweep marker",
   "cleanup-stale: error processing cache root",
   "cleanup-stale: rmSync failed",
+  "continuing this conversation's claude session under the new model or effort instead of replaying it",
   "delivering proxy results after interrupted continuation",
   "draining proxy calls queued between turns",
   "empty user content; sending sentinel to satisfy CLI",
@@ -5881,6 +6090,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "rejected pending proxy call",
   "remote URL images are not supported by Claude CLI, skipping",
   "replaying stdout the child emitted between turns",
+  "replaying the conversation as text: no claude session was available to continue",
   "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",
@@ -5936,6 +6146,7 @@ var BUNDLE_DATA_ALLOWLIST = {
   inFlight: "flag",
   anthropicApiKeyInEnv: "flag",
   includeHistoryContext: "flag",
+  resumable: "flag",
   interactive: "flag",
   interactiveTransport: "flag",
   isError: "flag",
@@ -5957,6 +6168,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   dropped: "count",
   exitCode: "count",
   historyLength: "count",
+  matchedMessages: "count",
+  messages: "count",
   inputTokens: "count",
   lastTextLength: "count",
   lines: "count",
@@ -6058,6 +6271,12 @@ var BUNDLE_DATA_ALLOWLIST = {
   sessionId: "id",
   sessionID: "id",
   sessionKey: "id",
+  // The two ends of a conversation carried from one session key to another
+  // (h #g215), and the fork lookup's parent. All three are session keys.
+  fromKey: "id",
+  toKey: "id",
+  siblingKey: "id",
+  parentKey: "id",
   toolCallId: "id",
   toolCallIds: "id",
   toolUseId: "id",
@@ -6294,8 +6513,8 @@ function redactLogLine(raw, context) {
   if (!parsed.data || Object.keys(parsed.data).length === 0) return head;
   return `${head} ${JSON.stringify(sanitizeLogData(parsed.data, context))}`;
 }
-function readLogTail(path11, maxBytes = BUNDLE_TAIL_BYTES) {
-  const fd = openSync(path11, "r");
+function readLogTail(path12, maxBytes = BUNDLE_TAIL_BYTES) {
+  const fd = openSync(path12, "r");
   try {
     const size = fstatSync(fd).size;
     const length = Math.min(size, maxBytes);
@@ -6445,13 +6664,20 @@ function parsePlanUsage(stdout) {
   return { status: "failed", error: "no result object in the CLI's reply" };
 }
 function runCli(cliPath, args, timeoutMs, env) {
+  const plan = planClaudeSpawn(cliPath, args);
   return new Promise((resolve6, reject) => {
     execFile2(
-      cliPath,
-      args,
+      plan.file,
+      plan.args,
       // `killSignal` so a CLI wedged on a hook is actually gone, and a generous
       // buffer because the reply is prose of unbounded length.
-      { timeout: timeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024, env },
+      {
+        timeout: timeoutMs,
+        killSignal: "SIGKILL",
+        maxBuffer: 4 * 1024 * 1024,
+        env,
+        windowsVerbatimArguments: plan.windowsVerbatimArguments
+      },
       (error, stdout) => {
         if (stdout && stdout.trim()) return resolve6(stdout);
         if (error) return reject(error);
@@ -6490,14 +6716,14 @@ async function fetchPlanUsage(cliPath, options = {}) {
 }
 
 // src/stale-build.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/startup-diagnostics.ts
 import { execFile as execFile3 } from "child_process";
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 import { promisify as promisify2 } from "util";
 import { fileURLToPath } from "url";
 
@@ -6532,8 +6758,8 @@ var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path5.dirname(fileURLToPath(import.meta.url));
-    const raw = fs4.readFileSync(path5.join(here, "..", "package.json"), "utf8");
+    const here = path6.dirname(fileURLToPath(import.meta.url));
+    const raw = fs5.readFileSync(path6.join(here, "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     cachedPluginVersion = typeof version === "string" ? version : "unknown";
   } catch {
@@ -6557,7 +6783,7 @@ var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
   opencodeVersionProbe = (async () => {
-    if (!path5.basename(execPath).toLowerCase().includes("opencode")) {
+    if (!path6.basename(execPath).toLowerCase().includes("opencode")) {
       log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
       return void 0;
     }
@@ -6786,10 +7012,10 @@ function defaultEntryPath() {
 }
 function readOnDiskBuild(entryPath) {
   try {
-    const raw = fs5.readFileSync(path6.join(path6.dirname(entryPath), "..", "package.json"), "utf8");
+    const raw = fs6.readFileSync(path7.join(path7.dirname(entryPath), "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     if (typeof version !== "string" || version.length === 0) return void 0;
-    const stat = fs5.statSync(entryPath);
+    const stat = fs6.statSync(entryPath);
     return { version, mtimeMs: stat.mtimeMs, size: stat.size };
   } catch {
     return void 0;
@@ -6800,7 +7026,7 @@ function recordLoadedBuild() {
   let mtimeMs;
   let size;
   try {
-    const stat = fs5.statSync(entryPath);
+    const stat = fs6.statSync(entryPath);
     mtimeMs = stat.mtimeMs;
     size = stat.size;
   } catch {
@@ -7237,7 +7463,7 @@ Could not build the report: ${message}`;
 
 // src/agent-models.ts
 import { readFile, readdir } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/models.ts
 var PROVIDER_ID = "claude-code";
@@ -7761,13 +7987,13 @@ async function readAgentMarkdownRecords(directories) {
       const name = entry.slice(0, -3);
       if (records2[name]) continue;
       try {
-        const text = await readFile(path7.join(directory, entry), "utf8");
+        const text = await readFile(path8.join(directory, entry), "utf8");
         records2[name] = parseAgentFrontmatter(text);
         const prompt = agentMarkdownBody(text);
         if (prompt) records2[name].prompt = prompt;
       } catch (err) {
         log.debug("failed to read agent markdown", {
-          file: path7.join(directory, entry),
+          file: path8.join(directory, entry),
           error: String(err)
         });
       }
@@ -7779,12 +8005,12 @@ function agentDirectories(home, projectDirectory) {
   const directories = [];
   if (projectDirectory) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path7.join(projectDirectory, ".opencode", name));
+      directories.push(path8.join(projectDirectory, ".opencode", name));
     }
   }
   if (home) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path7.join(home, ".config", "opencode", name));
+      directories.push(path8.join(home, ".config", "opencode", name));
     }
   }
   return directories;
@@ -8276,7 +8502,7 @@ The complete prior conversation appears above. The synthesis instructions follow
       content.push({
         type: "text",
         text: `<conversation_history>
-The following is a summary of our conversation so far (from a previous session that couldn't be resumed):
+The following is a summary of our conversation so far, replayed as text because no Claude session was available to continue it:
 
 ${historyContext}
 
@@ -8384,14 +8610,14 @@ function getTrailingUserMessages(prompt, opts = {}) {
 
 // src/skill-bridge.ts
 import * as crypto3 from "crypto";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as os3 from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function bundledSkillsDir() {
   try {
     const here = fileURLToPath3(import.meta.url);
-    const dir = path8.resolve(path8.dirname(here), "..", "skills");
+    const dir = path9.resolve(path9.dirname(here), "..", "skills");
     return dirExists2(dir) ? dir : null;
   } catch {
     return null;
@@ -8399,16 +8625,16 @@ function bundledSkillsDir() {
 }
 function dirExists2(p) {
   try {
-    return fs6.statSync(p).isDirectory();
+    return fs7.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function realPath(p) {
   try {
-    return fs6.realpathSync(p);
+    return fs7.realpathSync(p);
   } catch {
-    return path8.resolve(p);
+    return path9.resolve(p);
   }
 }
 function envEnabled(name) {
@@ -8429,10 +8655,10 @@ function declaredSkillName(source) {
   return SAFE_SKILL_NAME.test(name) ? name : null;
 }
 function readSkill(root, entry) {
-  const dir = path8.join(root, entry);
+  const dir = path9.join(root, entry);
   let source;
   try {
-    source = fs6.readFileSync(path8.join(dir, "SKILL.md"), "utf8");
+    source = fs7.readFileSync(path9.join(dir, "SKILL.md"), "utf8");
   } catch {
     return null;
   }
@@ -8450,47 +8676,47 @@ function skillRoots(cwd) {
   const roots = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path8.resolve(p);
+    const abs = path9.resolve(p);
     if (seen.has(abs)) return;
     seen.add(abs);
     if (dirExists2(abs)) roots.push(abs);
   };
   const home = os3.homedir();
-  const homeDir = home ? path8.resolve(home) : null;
-  let current = path8.resolve(cwd);
+  const homeDir = home ? path9.resolve(home) : null;
+  let current = path9.resolve(cwd);
   while (true) {
-    push(path8.join(current, ".opencode", "skills"));
+    push(path9.join(current, ".opencode", "skills"));
     if (current !== homeDir) {
-      push(path8.join(current, ".claude", "skills"));
-      push(path8.join(current, ".agents", "skills"));
+      push(path9.join(current, ".claude", "skills"));
+      push(path9.join(current, ".agents", "skills"));
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  if (homeDir) push(path8.join(homeDir, ".opencode", "skills"));
+  if (homeDir) push(path9.join(homeDir, ".opencode", "skills"));
   const envDir = process.env.OPENCODE_CONFIG_DIR;
   if (envDir) {
-    push(path8.join(envDir, "skills"));
-    push(path8.join(envDir, "skill"));
+    push(path9.join(envDir, "skills"));
+    push(path9.join(envDir, "skill"));
   }
-  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path8.join(homeDir, ".config") : null);
+  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path9.join(homeDir, ".config") : null);
   if (xdg) {
-    push(path8.join(xdg, "opencode", "skills"));
-    push(path8.join(xdg, "opencode", "skill"));
+    push(path9.join(xdg, "opencode", "skills"));
+    push(path9.join(xdg, "opencode", "skill"));
   }
   if (homeDir && !envEnabled("OPENCODE_DISABLE_EXTERNAL_SKILLS")) {
     if (!envEnabled("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")) {
-      push(path8.join(homeDir, ".claude", "skills"));
+      push(path9.join(homeDir, ".claude", "skills"));
     }
-    push(path8.join(homeDir, ".agents", "skills"));
+    push(path9.join(homeDir, ".agents", "skills"));
   }
   return roots;
 }
 function collectSkills(root, claimed, found) {
   let entries;
   try {
-    entries = fs6.readdirSync(root, { withFileTypes: true });
+    entries = fs7.readdirSync(root, { withFileTypes: true });
   } catch {
     return;
   }
@@ -8530,23 +8756,23 @@ function discoverBundledSkills() {
 }
 function claudeConfigDir(configDir) {
   const explicit = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (explicit) return path8.resolve(expandHome(explicit));
+  if (explicit) return path9.resolve(expandHome(explicit));
   const home = os3.homedir();
-  return home ? path8.resolve(home, ".claude") : null;
+  return home ? path9.resolve(home, ".claude") : null;
 }
 function installedPluginSkillRoots(configDir, cwd) {
   if (!configDir) return [];
   let parsed;
   try {
     parsed = JSON.parse(
-      fs6.readFileSync(path8.join(configDir, "plugins", "installed_plugins.json"), "utf8")
+      fs7.readFileSync(path9.join(configDir, "plugins", "installed_plugins.json"), "utf8")
     );
   } catch {
     return [];
   }
   const plugins = parsed?.plugins;
   if (!plugins || typeof plugins !== "object") return [];
-  const workspace = path8.resolve(cwd);
+  const workspace = path9.resolve(cwd);
   const roots = [];
   for (const installs of Object.values(plugins)) {
     if (!Array.isArray(installs)) continue;
@@ -8554,28 +8780,28 @@ function installedPluginSkillRoots(configDir, cwd) {
       const entry = install;
       if (typeof entry?.installPath !== "string" || !entry.installPath) continue;
       if (entry.scope !== "user" && !coversWorkspace(entry.projectPath, workspace)) continue;
-      roots.push(path8.join(entry.installPath, "skills"));
+      roots.push(path9.join(entry.installPath, "skills"));
     }
   }
   return roots;
 }
 function coversWorkspace(projectPath, workspace) {
   if (typeof projectPath !== "string" || !projectPath) return false;
-  const root = path8.resolve(projectPath);
+  const root = path9.resolve(projectPath);
   if (root === workspace) return true;
-  const rel = path8.relative(root, workspace);
-  return rel !== "" && !rel.startsWith("..") && !path8.isAbsolute(rel);
+  const rel = path9.relative(root, workspace);
+  return rel !== "" && !rel.startsWith("..") && !path9.isAbsolute(rel);
 }
 function discoverNativeClaudeSkills(opts) {
   const found = [];
   const scanned = /* @__PURE__ */ new Set();
   const scan = (root, scope) => {
-    const abs = path8.resolve(root);
+    const abs = path9.resolve(root);
     if (scanned.has(abs)) return;
     scanned.add(abs);
     let entries;
     try {
-      entries = fs6.readdirSync(abs, { withFileTypes: true });
+      entries = fs7.readdirSync(abs, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8587,13 +8813,13 @@ function discoverNativeClaudeSkills(opts) {
     }
   };
   const configDir = claudeConfigDir(opts.configDir);
-  if (configDir) scan(path8.join(configDir, "skills"), "user");
+  if (configDir) scan(path9.join(configDir, "skills"), "user");
   const home = os3.homedir();
-  const homeDir = home ? path8.resolve(home) : null;
-  let current = path8.resolve(opts.cwd);
+  const homeDir = home ? path9.resolve(home) : null;
+  let current = path9.resolve(opts.cwd);
   while (true) {
-    if (current !== homeDir) scan(path8.join(current, ".claude", "skills"), "project");
-    const parent = path8.dirname(current);
+    if (current !== homeDir) scan(path9.join(current, ".claude", "skills"), "project");
+    const parent = path9.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -8627,10 +8853,10 @@ function dropNativelyLoadedSkills(skills, native) {
 }
 function readBundledSkillInfos() {
   return discoverBundledSkills().flatMap((skill) => {
-    const file = path8.join(skill.dir, "SKILL.md");
+    const file = path9.join(skill.dir, "SKILL.md");
     let text;
     try {
-      text = fs6.readFileSync(file, "utf8");
+      text = fs7.readFileSync(file, "utf8");
     } catch {
       return [];
     }
@@ -8654,15 +8880,15 @@ function readBundledSkillInfos() {
 }
 function linkSkill(source, target) {
   try {
-    fs6.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+    fs7.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
     return;
   } catch {
-    fs6.cpSync(source, target, { recursive: true, dereference: true });
+    fs7.cpSync(source, target, { recursive: true, dereference: true });
   }
 }
 function fileExists2(p) {
   try {
-    return fs6.statSync(p).isFile();
+    return fs7.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -8671,14 +8897,14 @@ function buildSkillPluginDir(skills) {
   if (skills.length === 0) return null;
   const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
   const hash = crypto3.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
-  const root = path8.join(pluginTmpDir(), `skills-${hash}`);
-  const manifest = path8.join(root, ".claude-plugin", "plugin.json");
+  const root = path9.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path9.join(root, ".claude-plugin", "plugin.json");
   if (fileExists2(manifest)) return root;
   try {
-    fs6.rmSync(root, { recursive: true, force: true });
-    fs6.mkdirSync(path8.join(root, ".claude-plugin"), { recursive: true });
-    fs6.mkdirSync(path8.join(root, "skills"), { recursive: true });
-    fs6.writeFileSync(
+    fs7.rmSync(root, { recursive: true, force: true });
+    fs7.mkdirSync(path9.join(root, ".claude-plugin"), { recursive: true });
+    fs7.mkdirSync(path9.join(root, "skills"), { recursive: true });
+    fs7.writeFileSync(
       manifest,
       JSON.stringify(
         {
@@ -8691,7 +8917,7 @@ function buildSkillPluginDir(skills) {
       { encoding: "utf8", mode: 384 }
     );
     for (const skill of skills) {
-      linkSkill(skill.dir, path8.join(root, "skills", skill.name));
+      linkSkill(skill.dir, path9.join(root, "skills", skill.name));
     }
   } catch (err) {
     log.warn("failed to stage opencode skill plugin dir", {
@@ -8707,7 +8933,7 @@ function registerBundledSkillPath(config) {
   if (!dir) return false;
   config.skills ??= {};
   const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path8.resolve(p) === dir)) return false;
+  if (paths.some((p) => path9.resolve(p) === dir)) return false;
   paths.push(dir);
   return true;
 }
@@ -8761,12 +8987,13 @@ import { join as join10 } from "path";
 
 // src/claude-session-bun.ts
 import * as os4 from "os";
-import * as fs7 from "fs";
-import * as path9 from "path";
+import * as fs8 from "fs";
+import * as path10 from "path";
 import { execFileSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
+import { StringDecoder } from "string_decoder";
 function resolveClaude(cmd = "claude") {
-  if (path9.isAbsolute(cmd) && fs7.existsSync(cmd)) return cmd;
+  if (path10.isAbsolute(cmd) && fs8.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
   const isWin = os4.platform() === "win32";
@@ -8775,24 +9002,30 @@ function resolveClaude(cmd = "claude") {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs7.existsSync(p));
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs8.existsSync(p));
     if (first) return first;
   } catch {
   }
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  const resolved = path9.resolve(cwd);
+  const resolved = path10.resolve(cwd);
   let real = resolved;
   try {
-    real = fs7.realpathSync.native(resolved);
+    real = fs8.realpathSync.native(resolved);
   } catch {
   }
   return real.replace(/[^a-zA-Z0-9]/g, "-");
 }
 var bunPtySpawner = (argv, opts) => {
   const [command, ...args] = argv;
-  return Bun.spawn([resolveClaude(command ?? "claude"), ...args], {
+  const resolved = resolveClaude(command ?? "claude");
+  if (os4.platform() === "win32" && isBatchFile(resolved)) {
+    throw new Error(
+      `The interactive transport cannot run a Windows batch shim (${resolved}). Point \`cliPath\` at claude.exe, or use the default headless transport.`
+    );
+  }
+  return Bun.spawn([resolved, ...args], {
     cwd: opts.cwd,
     env: opts.env,
     terminal: {
@@ -9007,6 +9240,123 @@ function isInterruptRecord(rec) {
 function isTurnDurationRecord(rec) {
   return rec?.type === "system" && rec.subtype === "turn_duration";
 }
+var TRANSCRIPT_CHUNK_BYTES = 1 << 20;
+var TranscriptCursor = class {
+  /** The path is asked for on every poll rather than kept, because it is a
+   *  field of the session and a test may repoint it; a path that changes is
+   *  a different file, which the `dev:ino` check already starts over on. */
+  constructor(resolvePath) {
+    this.resolvePath = resolvePath;
+  }
+  resolvePath;
+  /** Bytes of the current file already read. */
+  offset = 0;
+  /** `dev:ino` of the file those bytes came from, null before the first
+   *  successful stat. A different one is a new file, not growth. */
+  fileId = null;
+  /** Holds back an incomplete trailing UTF-8 sequence between two reads. */
+  decoder = new StringDecoder("utf8");
+  /** What was read after the last newline: a record the CLI is part way
+   *  through writing, completed by a later read. */
+  partial = "";
+  /** Complete lines seen since byte 0 of the current file. */
+  seen = 0;
+  /** Complete lines handed on: the line-index cursor. */
+  taken = 0;
+  /** Complete lines read and not handed on yet, oldest first. */
+  queue = [];
+  stats = { polls: 0, reads: 0, bytes: 0 };
+  /** Complete lines in the file now. */
+  lineCount() {
+    this.poll(true);
+    return this.seen;
+  }
+  /** The complete lines not handed on yet, oldest first. They stay queued
+   *  until `take` says how many of them were used. */
+  pending() {
+    this.poll(true);
+    return this.queue;
+  }
+  /** Whether the file holds a complete line this cursor has not handed on. */
+  hasUnread() {
+    return this.pending().length > 0;
+  }
+  /** Mark the first `count` pending lines as handed on. */
+  take(count) {
+    const used = Math.min(count, this.queue.length);
+    if (used <= 0) return;
+    this.queue.splice(0, used);
+    this.taken += used;
+  }
+  /** Hand on nothing of what is in the file now: the records written before a
+   *  turn started belong to the turn before it. */
+  skipToEnd() {
+    this.poll(false);
+    this.taken = Math.max(this.taken, this.seen);
+    this.queue.length = 0;
+  }
+  /** Read whatever was appended since the last look. */
+  poll(collect) {
+    this.stats.polls++;
+    const filePath = this.resolvePath();
+    let stat;
+    try {
+      stat = fs8.statSync(filePath);
+    } catch {
+      return;
+    }
+    const fileId = `${stat.dev}:${stat.ino}`;
+    if (this.fileId !== null && (fileId !== this.fileId || stat.size < this.offset)) {
+      this.offset = 0;
+      this.seen = 0;
+      this.partial = "";
+      this.decoder = new StringDecoder("utf8");
+      this.queue.length = 0;
+    }
+    this.fileId = fileId;
+    if (stat.size <= this.offset) return;
+    let fd = null;
+    try {
+      fd = fs8.openSync(filePath, "r");
+      const buffer = Buffer.allocUnsafe(
+        Math.min(TRANSCRIPT_CHUNK_BYTES, stat.size - this.offset)
+      );
+      while (this.offset < stat.size) {
+        const want = Math.min(buffer.length, stat.size - this.offset);
+        const read = fs8.readSync(fd, buffer, 0, want, this.offset);
+        this.stats.reads++;
+        if (read <= 0) break;
+        this.offset += read;
+        this.stats.bytes += read;
+        this.ingest(this.decoder.write(buffer.subarray(0, read)), collect);
+      }
+    } catch {
+    } finally {
+      if (fd !== null) {
+        try {
+          fs8.closeSync(fd);
+        } catch {
+        }
+      }
+    }
+  }
+  /** Split decoded text into complete lines, keeping the unterminated tail. */
+  ingest(text, collect) {
+    if (!text) return;
+    this.partial += text;
+    let start = 0;
+    for (; ; ) {
+      const newline = this.partial.indexOf("\n", start);
+      if (newline === -1) break;
+      if (collect && this.seen >= this.taken) {
+        this.queue.push(this.partial.slice(start, newline));
+      }
+      this.seen++;
+      start = newline + 1;
+    }
+    if (start > 0) this.partial = this.partial.slice(start);
+  }
+};
 var normalizedPrompt = (text) => text.replace(/\s+/g, " ").trim();
 function isOwnPromptRecord(rec, normalized) {
   const content = rec?.type === "user" ? rec.message?.content : void 0;
@@ -9014,12 +9364,12 @@ function isOwnPromptRecord(rec, normalized) {
 }
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path9.join(os4.homedir(), ".claude");
+  if (!value) return path10.join(os4.homedir(), ".claude");
   if (value === "~") return os4.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path9.join(os4.homedir(), value.slice(2));
+    return path10.join(os4.homedir(), value.slice(2));
   }
-  return path9.resolve(value);
+  return path10.resolve(value);
 }
 function fatalScreenMessage(kind, configDir, cwd) {
   if (kind === "trust") {
@@ -9038,8 +9388,8 @@ var ClaudeSession = class {
   /** The newest terminal output, ANSI included, for diagnostics. */
   raw = "";
   proc = null;
-  cursor = 0;
-  // index into transcript split('\n')
+  /** The transcript, read forwards only; its `taken` is the old line cursor. */
+  transcript;
   lastDataAt = 0;
   exited = false;
   exitCode = null;
@@ -9083,7 +9433,7 @@ var ClaudeSession = class {
   abandonTurn = false;
   o;
   constructor(opts = {}) {
-    this.cwd = path9.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path10.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.explicitConfigDir = opts.configDir ? this.configDir : void 0;
     this.signal = opts.signal;
@@ -9095,12 +9445,13 @@ var ClaudeSession = class {
     this.onExit = opts.onExit;
     this.spawnPty = opts.spawnPty ?? bunPtySpawner;
     this.sessionId = opts.resumeSessionId ?? randomUUID4();
-    this.jsonlPath = path9.join(
+    this.jsonlPath = path10.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
       `${this.sessionId}.jsonl`
     );
+    this.transcript = new TranscriptCursor(() => this.jsonlPath);
     this.o = {
       cwd: this.cwd,
       cliPath: opts.cliPath,
@@ -9205,7 +9556,12 @@ var ClaudeSession = class {
     };
     proc.exited.then((code) => markExited(typeof code === "number" ? code : null)).catch(() => markExited(null));
     await this.waitForBoot();
-    this.cursor = this.lineCount();
+    this.transcript.skipToEnd();
+  }
+  /** How much this session has read off the transcript. Read-only, and the
+   *  one thing `scripts/bench-transcript-poll.ts` measures. */
+  get transcriptStats() {
+    return this.transcript.stats;
   }
   onData(chunk) {
     this.lastDataAt = Date.now();
@@ -9352,22 +9708,10 @@ var ClaudeSession = class {
       while (Date.now() < until) {
         await delay(80);
         if (this.aborted || this.exited) return;
-        if (this.lineCount() > this.cursor) return;
+        if (this.transcript.hasUnread()) return;
       }
     }
   }
-  readRawLines() {
-    try {
-      return fs7.readFileSync(this.jsonlPath, "utf8").split("\n");
-    } catch {
-      return [];
-    }
-  }
-  /** Count of complete lines (split('\n') minus the trailing/partial element). */
-  lineCount() {
-    const lines = this.readRawLines();
-    return lines.length > 0 ? lines.length - 1 : 0;
-  }
   rawTail(max = 600) {
     const clean = stripTerminal(this.raw).replace(/\s+/g, " ").trim();
     return clean.length > max ? clean.slice(-max) : clean;
@@ -9400,7 +9744,7 @@ var ClaudeSession = class {
     this.turn = new Promise((resolve6) => settle = resolve6);
     this.turnDenied = [];
     this.abandonTurn = false;
-    this.cursor = Math.max(this.cursor, this.lineCount());
+    this.transcript.skipToEnd();
     this.screen = "";
     try {
       if (this.o.bracketedPaste) {
@@ -9465,30 +9809,26 @@ var ClaudeSession = class {
   /**
    * Read every complete transcript record past the cursor into the running
    * turn. Returns whether anything new was read. The one place a record is
-   * interpreted, shared by the poll loop and `flushTranscript`.
+   * interpreted, shared by the poll loop and `flushTranscript`, and the only
+   * one that consumes what `TranscriptCursor` has queued.
    */
   scanTranscript() {
     const scan = this.scan;
     if (!scan || scan.end) return false;
-    const lines = this.readRawLines();
-    const lastComplete = lines.length - 1;
-    if (lastComplete <= this.cursor) return false;
-    for (let i = this.cursor; i < lastComplete && !scan.end; i++) {
+    const lines = this.transcript.pending().slice();
+    if (lines.length === 0) return false;
+    let used = 0;
+    for (let i = 0; i < lines.length && !scan.end; i++) {
       const s = lines[i];
-      if (!s || !s.trim()) {
-        this.cursor = i + 1;
-        continue;
-      }
+      used = i + 1;
+      if (!s || !s.trim()) continue;
       let rec = null;
       try {
         rec = JSON.parse(s);
       } catch {
       }
       if (scan.awaitingOwnPrompt !== null) {
-        if (!isOwnPromptRecord(rec, scan.awaitingOwnPrompt)) {
-          this.cursor = i + 1;
-          continue;
-        }
+        if (!isOwnPromptRecord(rec, scan.awaitingOwnPrompt)) continue;
         scan.awaitingOwnPrompt = null;
       }
       if (rec) this.notePlanApproval(rec);
@@ -9508,9 +9848,8 @@ var ClaudeSession = class {
           scan.end = scan.stopReason ? "stop" : "ended";
         }
       }
-      this.cursor = i + 1;
     }
-    if (!scan.end) this.cursor = lastComplete;
+    this.transcript.take(used);
     scan.lastBeat = Date.now();
     scan.stopSeenAt = Date.now();
     return true;
@@ -10299,13 +10638,13 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir8 } from "os";
 import { randomUUID as randomUUID6 } from "crypto";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join11 } from "path";
-function readPromptFileIfPresent(path11) {
+function readPromptFileIfPresent(path12) {
   try {
-    const content = readFileSync7(path11, "utf8").trim();
+    const content = readFileSync6(path12, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -10410,9 +10749,9 @@ function extractSystemMessages(prompt) {
 }
 var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLAUDE.local.md"]);
 function userAuthoredInstructions(forwarded, opts = {}) {
-  const readFile2 = opts.readFile ?? ((path11) => {
+  const readFile2 = opts.readFile ?? ((path12) => {
     try {
-      return readFileSync7(path11, "utf8");
+      return readFileSync6(path12, "utf8");
     } catch {
       return null;
     }
@@ -10424,16 +10763,16 @@ function userAuthoredInstructions(forwarded, opts = {}) {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const match of forwarded.matchAll(/^Instructions from: (.+)$/gm)) {
-    const path11 = match[1].trim();
-    if (seen.has(path11) || !isAbsolute3(path11)) continue;
-    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path11))) continue;
-    seen.add(path11);
-    const file = readFile2(path11);
+    const path12 = match[1].trim();
+    if (seen.has(path12) || !isAbsolute3(path12)) continue;
+    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path12))) continue;
+    seen.add(path12);
+    const file = readFile2(path12);
     if (!file?.trim()) continue;
     const start = match.index + match[0].length + 1;
     const content = forwarded.startsWith(file, start) ? file : forwarded.startsWith(file.trimEnd(), start) ? file.trimEnd() : null;
     if (content === null) continue;
-    out.push({ text: `Instructions from: ${path11}
+    out.push({ text: `Instructions from: ${path12}
 ${content}`, content });
   }
   return out;
@@ -10470,10 +10809,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path11 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID6()}.md`);
+  const path12 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID6()}.md`);
   try {
-    writeFileSync6(path11, content, { encoding: "utf8", mode: 384 });
-    return path11;
+    writeFileSync6(path12, content, { encoding: "utf8", mode: 384 });
+    return path12;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -11326,6 +11665,7 @@ function createTurnState(init) {
     accountLimitHit: null,
     apiErrorTextShown: null,
     usageLimitNote: false,
+    compactionFailureText: null,
     accountBlock: null,
     modelRefusal: null,
     drainBuffer: [],
@@ -12420,6 +12760,7 @@ ${plan}
           resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
         }));
         const limitErrorReply = limitFromReply && ctx.usageLimitNoteActive;
+        const compactionApiError = ctx.compactionMode && (apiErrorReply || typeof msg.error === "string");
         if (limitFromReply) {
           state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
           const said = limitFactsFromText(
@@ -12441,6 +12782,10 @@ ${plan}
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
             if (limitErrorReply) continue;
+            if (compactionApiError) {
+              state.compactionFailureText ??= block2.text;
+              continue;
+            }
             if (apiErrorReply) state.apiErrorTextShown = block2.text;
             resetLastVisibleTextBlock(state);
             const blockId = state.startTextBlock();
@@ -12666,7 +13011,14 @@ ${plan}
         state.usageLimitNote = ctx.usageLimitNoteActive && !!state.accountLimitHit && // An expired login or a billing hold writes its own note just below
         // and says what to run; two notes about one failure is one too many.
         !state.accountBlock && msg.is_error === true;
-        if (!state.currentTextId && msg.is_error && // Already on screen from the reply frame, word for word.
+        const compactionFailure = ctx.compactionMode && (msg.is_error === true || typeof msg.subtype === "string" && msg.subtype !== "success");
+        if (compactionFailure) {
+          if (typeof msg.result === "string" && msg.result.trim()) {
+            state.compactionFailureText ??= msg.result.trim();
+          }
+          state.resultFailure ??= state.accountBlock ?? (state.accountLimitHit ? "usage_limit" : void 0) ?? (typeof msg.subtype === "string" && msg.subtype !== "success" ? msg.subtype : "error");
+        }
+        if (!state.currentTextId && msg.is_error && !compactionFailure && // Already on screen from the reply frame, word for word.
         !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
@@ -12681,21 +13033,23 @@ ${plan}
         if (state.accountBlock && msg.is_error) {
           state.resultFailure ??= state.accountBlock;
           const offeringSwitch = ctx.failoverAskActive;
-          state.controller.enqueue({
-            type: "text-delta",
-            id: state.startTextBlock(),
-            delta: formatAccountBlockNote({
-              kind: state.accountBlock,
-              account: ctx.sourceAccount,
-              configDir: ctx.config.configDir,
-              offeringSwitch,
-              // Read only when the form is not taking the turn, which is the
-              // default: moving the work by hand is then the operator's only
-              // route and nothing else on screen says it exists (h #g194).
-              candidates: ctx.failoverAccounts
-            })
-          });
-          state.endTextBlock();
+          if (!compactionFailure) {
+            state.controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatAccountBlockNote({
+                kind: state.accountBlock,
+                account: ctx.sourceAccount,
+                configDir: ctx.config.configDir,
+                offeringSwitch,
+                // Read only when the form is not taking the turn, which is the
+                // default: moving the work by hand is then the operator's only
+                // route and nothing else on screen says it exists (h #g194).
+                candidates: ctx.failoverAccounts
+              })
+            });
+            state.endTextBlock();
+          }
           log.warn(`Claude account "${ctx.sourceAccount}" cannot serve requests`, {
             sessionKey: state.sessionKey,
             kind: state.accountBlock,
@@ -12705,11 +13059,14 @@ ${plan}
         const failure = describeResultFailure(msg);
         if (failure) {
           state.resultFailure = msg.subtype;
-          state.controller.enqueue({
-            type: "text-delta",
-            id: state.startTextBlock(),
-            delta: formatResultFailureNote(failure)
-          });
+          if (!compactionFailure) {
+            state.controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatResultFailureNote(failure)
+            });
+          }
+          if (compactionFailure) state.compactionFailureText ??= failure;
           log.warn(failure, { sessionKey: state.sessionKey, subtype: msg.subtype });
         }
         const turnStats = extractTurnStats(msg);
@@ -13519,13 +13876,18 @@ var ClaudeCodeLanguageModel = class {
         }
       }
     }
+    let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
+      const transcriptPath = (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
         cliPath,
-        transcriptPath: (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`)
+        transcriptPath,
+        onRefused: (reason) => {
+          replayReason = reason;
+        }
       });
       if (resumePoint) {
         setClaudeSessionId(sk, resumePoint.claudeSessionId);
@@ -13534,8 +13896,47 @@ var ClaudeCodeLanguageModel = class {
           sessionKey: sk,
           matchedMessages: resumePoint.matched
         });
+      } else if (this.config.resumeAcrossModelChanges !== false) {
+        const sibling = findSiblingResumePoint({
+          sessionKey: sk,
+          prompt: options.prompt,
+          cliPath,
+          transcriptPath,
+          // `claudeSessionIsWriting`, not `getActiveProcess`: this walks every
+          // sibling key, and that one refreshes LRU order and cancels idle
+          // timers on everything it touches (the same reason the fork lookup
+          // above uses it).
+          isBusy: claudeSessionIsWriting,
+          onRefused: (reason) => {
+            replayReason = reason;
+          }
+        });
+        if (sibling) {
+          deleteActiveProcess(sibling.siblingKey);
+          const carried = transferClaudeSession(sibling.siblingKey, sk);
+          if (carried) {
+            includeHistoryContext = false;
+            log.notice(
+              "continuing this conversation's claude session under the new model or effort instead of replaying it",
+              {
+                sessionKey: sk,
+                siblingKey: sibling.siblingKey,
+                matchedMessages: sibling.matched
+              }
+            );
+          } else {
+            replayReason = "sibling-carry-over-failed";
+          }
+        }
       }
     }
+    if (includeHistoryContext && !compactionMode) {
+      log.notice("replaying the conversation as text: no claude session was available to continue", {
+        sessionKey: sk,
+        reason: replayReason,
+        messages: options.prompt.length
+      });
+    }
     if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
@@ -14288,6 +14689,7 @@ var ClaudeCodeLanguageModel = class {
                 })
               });
               state.endTextBlock();
+              state.resultFailure ??= "usage_limit";
             }
             if (runAutoContinue(state, msg)) return;
             for (const [idx, reasoningId] of state.reasoningIds) {
@@ -14321,6 +14723,18 @@ var ClaudeCodeLanguageModel = class {
               });
               state.endTextBlock();
             }
+            if (compactionMode && state.resultFailure) {
+              log.warn("claude could not compact the conversation; no summary was stored", {
+                sessionKey: sk,
+                cause: state.resultFailure
+              });
+              controller.enqueue({
+                type: "error",
+                error: new Error(
+                  formatCompactionFailure(state.resultFailure, state.compactionFailureText)
+                )
+              });
+            }
             const usage = toUsage2(lastCallContextUsage(state.lastCallUsage, msg.usage));
             controller.enqueue({
               type: "finish",
@@ -14716,7 +15130,7 @@ var ClaudeCodeLanguageModel = class {
 import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync7,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
   writeFileSync as writeFileSync7
@@ -14743,7 +15157,7 @@ function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync8(cfg, "utf8"));
+    const json = JSON.parse(readFileSync7(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -14764,7 +15178,7 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync8(join13(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync7(join13(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
@@ -14776,7 +15190,7 @@ function markerPath() {
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync8(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync7(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -14833,7 +15247,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync8(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync7(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -14852,7 +15266,7 @@ function cleanupOne(cacheRoot, ourDir) {
   const cachePkgJson = join13(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync8(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync7(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync7(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -14932,7 +15346,7 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path10 from "path";
+import path11 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -14961,7 +15375,7 @@ function toV1Session(info) {
   if (!info || typeof info !== "object") return void 0;
   const session = info;
   const root = session.location?.directory;
-  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path10.resolve(root, session.subpath) : root : void 0;
+  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path11.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {
@@ -15519,6 +15933,7 @@ function createClaudeCode(settings = {}) {
       turnStats: settings.turnStats === true,
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
+      resumeAcrossModelChanges: settings.resumeAcrossModelChanges !== false,
       transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,