@khalilgharbaoui/opencode-claude-code-plugin 0.46.0 → 0.47.0

package/dist/index.js

@@ -1490,7 +1490,7 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
           options: [
             ...candidates.map((candidate) => ({
               label: candidate,
-              description: `Run on "${candidate}" until ${until}. The conversation is replayed as a fresh Claude session (a session cannot resume across accounts), and any MCP server configured only in "${source}"'s Claude profile will be missing.`
+              description: input.carryTranscript === false ? `Run on "${candidate}" until ${until}. The conversation is replayed as a fresh Claude session, and any MCP server configured only in "${source}"'s Claude profile will be missing.` : `Run on "${candidate}" until ${until}. The conversation continues where it stopped if its Claude transcript can be carried across, and is replayed as a fresh Claude session if it cannot; either way, any MCP server configured only in "${source}"'s Claude profile will be missing.`
             })),
             {
               label: STOP_ANSWER,
@@ -1601,20 +1601,20 @@ function stripAccountFailoverParts(prompt) {
   }
   return changed ? out : prompt;
 }
-function failoverContinuationText(target) {
+function failoverContinuationText(target, resumed = false) {
   return [
-    `The Claude account this conversation was running on hit its usage limit, so it has been moved to the "${target}" account and you are now in a fresh Claude session.`,
-    "The conversation so far is above. Continue the task from where it stopped: do not start over, do not re-plan, and do not repeat work that is already done.",
+    resumed ? `The Claude account this conversation was running on hit its usage limit, so it has been moved to the "${target}" account. This is the same conversation, continued: everything you already know still stands.` : `The Claude account this conversation was running on hit its usage limit, so it has been moved to the "${target}" account and you are now in a fresh Claude session. The conversation so far is above.`,
+    "Continue the task from where it stopped: do not start over, do not re-plan, and do not repeat work that is already done.",
     "Do not mention the account switch unless you are asked about it."
   ].join(" ");
 }
-function buildFailoverContinuationPrompt(prompt, target) {
+function buildFailoverContinuationPrompt(prompt, target, resumed = false) {
   const stripped = stripAccountFailoverParts(prompt);
   return [
     ...stripped,
     {
       role: "user",
-      content: [{ type: "text", text: failoverContinuationText(target) }]
+      content: [{ type: "text", text: failoverContinuationText(target, resumed) }]
     }
   ];
 }
@@ -1625,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;
@@ -1672,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());
@@ -1769,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",
@@ -1805,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
@@ -1838,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}`
 );
@@ -1861,7 +1962,7 @@ function currentUid() {
 function untrustworthyReason(dir) {
   let stat;
   try {
-    stat = fs.lstatSync(dir);
+    stat = fs2.lstatSync(dir);
   } catch {
     return null;
   }
@@ -1874,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,
@@ -1897,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 {
       }
     }
@@ -1918,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;
     }
@@ -1942,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", {
@@ -2773,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;
     },
@@ -2794,7 +2895,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       });
       if (configFilePath) {
         try {
-          fs2.unlinkSync(configFilePath);
+          fs3.unlinkSync(configFilePath);
         } catch {
         }
         configFilePath = null;
@@ -3363,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 {
@@ -3375,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) {
@@ -3425,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;
   }
@@ -3440,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);
@@ -3471,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);
@@ -3482,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);
@@ -3498,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;
@@ -3645,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);
@@ -3712,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", {
@@ -5308,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 = {
@@ -5892,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",
+  "carried this conversation's claude transcript to the other account",
   "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",
@@ -5989,6 +6092,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",
   "replaying the conversation as text: no claude session was available to continue",
+  "replaying this conversation as text on the other account",
   "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",
@@ -6033,6 +6137,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   emitted: "flag",
   enabled: "flag",
   executed: "flag",
+  failedOver: "flag",
+  renamed: "flag",
   isUsingOverage: "flag",
   hadProxyActivity: "flag",
   hadReasoning: "flag",
@@ -6411,8 +6517,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(path13, maxBytes = BUNDLE_TAIL_BYTES) {
+  const fd = openSync(path13, "r");
   try {
     const size = fstatSync(fd).size;
     const length = Math.min(size, maxBytes);
@@ -6562,13 +6668,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);
@@ -6607,14 +6720,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";
 
@@ -6649,8 +6762,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 {
@@ -6674,7 +6787,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;
     }
@@ -6903,10 +7016,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;
@@ -6917,7 +7030,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 {
@@ -7354,7 +7467,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";
@@ -7878,13 +7991,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)
         });
       }
@@ -7896,12 +8009,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;
@@ -8501,14 +8614,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;
@@ -8516,16 +8629,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) {
@@ -8546,10 +8659,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;
   }
@@ -8567,47 +8680,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;
   }
@@ -8647,23 +8760,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;
@@ -8671,28 +8784,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;
     }
@@ -8704,13 +8817,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;
   }
@@ -8744,10 +8857,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 [];
     }
@@ -8771,15 +8884,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;
   }
@@ -8788,14 +8901,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(
         {
@@ -8808,7 +8921,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", {
@@ -8824,7 +8937,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;
 }
@@ -8878,12 +8991,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";
@@ -8892,24 +9006,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: {
@@ -9011,6 +9131,14 @@ function classifyScreen(text) {
   }
   return null;
 }
+function interactiveTranscriptPath(opts) {
+  return path10.join(
+    resolveConfigDir(opts.configDir),
+    "projects",
+    encodeCwd(path10.resolve(opts.cwd)),
+    `${opts.sessionId}.jsonl`
+  );
+}
 function configDirEnv(configDir) {
   return configDir ? { CLAUDE_CONFIG_DIR: configDir } : {};
 }
@@ -9124,6 +9252,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;
@@ -9131,12 +9376,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") {
@@ -9155,8 +9400,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;
@@ -9200,7 +9445,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;
@@ -9212,12 +9457,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,
@@ -9322,7 +9568,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();
@@ -9469,22 +9720,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;
@@ -9517,7 +9756,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) {
@@ -9582,30 +9821,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);
@@ -9625,9 +9860,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;
@@ -10415,14 +10649,74 @@ function spawnInteractiveProcess(opts) {
   return ap;
 }
 
+// src/account-transcript.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { constants as fsConstants } from "fs";
+import { chmod as chmod2, copyFile, lstat as lstat2, mkdir as mkdir2 } from "fs/promises";
+import path11 from "path";
+var transcriptPath = interactiveTranscriptPath;
+function configDirForAccount(account) {
+  const normalized = normalizeAccountName(account || DEFAULT_ACCOUNT);
+  return resolveConfigDir(
+    normalized === DEFAULT_ACCOUNT ? void 0 : accountConfigDirPath(normalized)
+  );
+}
+async function carryTranscriptToAccount(input) {
+  const { sessionId, cwd, targetConfigDir } = input;
+  const targetOwn = transcriptPath({ configDir: targetConfigDir, cwd, sessionId });
+  const targetOwnStat = await statTranscript(targetOwn);
+  if (targetOwnStat.kind === "other") {
+    return { kind: "refused", reason: "target-not-a-file", detail: targetOwn };
+  }
+  let live;
+  for (const dir of dedupe2([targetConfigDir, ...input.accountConfigDirs])) {
+    const candidate = transcriptPath({ configDir: dir, cwd, sessionId });
+    const stat = candidate === targetOwn ? targetOwnStat : await statTranscript(candidate);
+    if (stat.kind !== "file") continue;
+    if (!live || stat.size > live.size) live = { file: candidate, size: stat.size };
+  }
+  if (!live) return { kind: "refused", reason: "no-transcript-anywhere" };
+  if (live.file === targetOwn) return { kind: "already-there", sessionId };
+  const renamed = targetOwnStat.kind === "file";
+  const carriedId = renamed ? (input.newSessionId ?? randomUUID6)() : sessionId;
+  const target = renamed ? transcriptPath({ configDir: targetConfigDir, cwd, sessionId: carriedId }) : targetOwn;
+  try {
+    await mkdir2(path11.dirname(target), { recursive: true, mode: 448 });
+    await copyFile(live.file, target, fsConstants.COPYFILE_EXCL);
+    await chmod2(target, 384);
+  } catch (err) {
+    return { kind: "refused", reason: "copy-failed", detail: String(err) };
+  }
+  return { kind: "carried", sessionId: carriedId, from: live.file, to: target, renamed };
+}
+async function statTranscript(file) {
+  try {
+    const stat = await lstat2(file);
+    return stat.isFile() ? { kind: "file", size: stat.size } : { kind: "other", size: 0 };
+  } catch {
+    return { kind: "none", size: 0 };
+  }
+}
+function dedupe2(dirs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const dir of dirs) {
+    const resolved = path11.resolve(dir);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    out.push(resolved);
+  }
+  return out;
+}
+
 // 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 { randomUUID as randomUUID7 } from "crypto";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join11 } from "path";
-function readPromptFileIfPresent(path11) {
+function readPromptFileIfPresent(path13) {
   try {
-    const content = readFileSync7(path11, "utf8").trim();
+    const content = readFileSync6(path13, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -10527,9 +10821,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 ?? ((path13) => {
     try {
-      return readFileSync7(path11, "utf8");
+      return readFileSync6(path13, "utf8");
     } catch {
       return null;
     }
@@ -10541,16 +10835,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 path13 = match[1].trim();
+    if (seen.has(path13) || !isAbsolute3(path13)) continue;
+    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path13))) continue;
+    seen.add(path13);
+    const file = readFile2(path13);
     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: ${path13}
 ${content}`, content });
   }
   return out;
@@ -10587,10 +10881,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 path13 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync6(path11, content, { encoding: "utf8", mode: 384 });
-    return path11;
+    writeFileSync6(path13, content, { encoding: "utf8", mode: 384 });
+    return path13;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -13606,12 +13900,51 @@ var ClaudeCodeLanguageModel = class {
         failedOver: failover.failedOver
       });
       deleteActiveProcess(sk);
+    }
+    let conversationOnTarget = false;
+    const multiAccount = (this.config.failoverAccounts?.length ?? 0) > 1;
+    const sessionBeforeAccountCheck = getClaudeSessionId(sk);
+    if (!compactionMode && multiAccount && this.config.crossAccountResume !== false && sessionBeforeAccountCheck) {
+      const carry = await carryTranscriptToAccount({
+        sessionId: sessionBeforeAccountCheck,
+        cwd,
+        targetConfigDir: resolveConfigDir(this.skillBridgeSpawn(failover).configDir),
+        // Every account's own directory, plus this model's configured one:
+        // `configDir` is an option, so an account's directory is not always
+        // the `~/.claude-<name>` the name alone would build.
+        accountConfigDirs: [
+          ...(this.config.failoverAccounts ?? []).map(configDirForAccount),
+          resolveConfigDir(this.config.configDir)
+        ]
+      });
+      if (carry.kind === "carried" || carry.kind === "already-there") {
+        if (carry.sessionId !== sessionBeforeAccountCheck) {
+          setClaudeSessionId(sk, carry.sessionId);
+        }
+        conversationOnTarget = true;
+        if (carry.kind === "carried") {
+          log.notice("carried this conversation's claude transcript to the other account", {
+            sessionKey: sk,
+            renamed: carry.renamed,
+            sessionId: carry.sessionId,
+            failedOver: failover.failedOver
+          });
+        }
+      } else if (!getActiveProcess(sk)) {
+        log.notice("replaying this conversation as text on the other account", {
+          sessionKey: sk,
+          reason: carry.reason,
+          failedOver: failover.failedOver
+        });
+        deleteClaudeSessionId(sk);
+      }
+    } else if (!compactionMode && sessionBeforeAccountCheck && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
       deleteClaudeSessionId(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
     let includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
-    if (failoverAnswer?.kind === "switch" && hasPriorConversation) {
+    if (failoverAnswer?.kind === "switch" && hasPriorConversation && !conversationOnTarget) {
       includeHistoryContext = true;
     }
     let forkFromClaudeSessionId;
@@ -13657,12 +13990,12 @@ 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 transcriptPath2 = (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
         cliPath,
-        transcriptPath,
+        transcriptPath: transcriptPath2,
         onRefused: (reason) => {
           replayReason = reason;
         }
@@ -13679,7 +14012,7 @@ var ClaudeCodeLanguageModel = class {
           sessionKey: sk,
           prompt: options.prompt,
           cliPath,
-          transcriptPath,
+          transcriptPath: transcriptPath2,
           // `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
@@ -13724,7 +14057,11 @@ var ClaudeCodeLanguageModel = class {
       log.info("sending plan approval decision to claude", { sk });
     }
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
-    const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(options.prompt, failoverAnswer.target) : options.prompt;
+    const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(
+      options.prompt,
+      failoverAnswer.target,
+      conversationOnTarget
+    ) : options.prompt;
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(effectivePrompt, includeHistoryContext, {
       compactionMode,
       compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
@@ -14406,7 +14743,8 @@ var ClaudeCodeLanguageModel = class {
                 candidates: failoverAccounts,
                 resetsAt: state.accountLimitHit?.resetsAt,
                 window: state.accountLimitHit?.window,
-                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock)
+                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock),
+                carryTranscript: self.config.crossAccountResume !== false
               });
               log.warn(
                 `Claude account "${sourceAccount}" ${state.accountLimitHit || !state.accountBlock ? "is out of usage" : `cannot serve (${state.accountBlock})`}; asking which account to continue on.`,
@@ -14908,7 +15246,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
@@ -14935,7 +15273,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(
@@ -14956,7 +15294,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;
@@ -14968,7 +15306,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;
@@ -15025,7 +15363,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;
   }
@@ -15044,7 +15382,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");
@@ -15124,7 +15462,7 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path10 from "path";
+import path12 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -15153,7 +15491,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 ? path12.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {
@@ -15712,6 +16050,7 @@ function createClaudeCode(settings = {}) {
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
       resumeAcrossModelChanges: settings.resumeAcrossModelChanges !== false,
+      crossAccountResume: settings.crossAccountResume !== false,
       transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,