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

package/dist/index.js

@@ -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 = {
@@ -6411,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);
@@ -6562,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);
@@ -6607,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";
 
@@ -6649,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 {
@@ -6674,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;
     }
@@ -6903,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;
@@ -6917,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 {
@@ -7354,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";
@@ -7878,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)
         });
       }
@@ -7896,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;
@@ -8501,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;
@@ -8516,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) {
@@ -8546,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;
   }
@@ -8567,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;
   }
@@ -8647,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;
@@ -8671,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;
     }
@@ -8704,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;
   }
@@ -8744,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 [];
     }
@@ -8771,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;
   }
@@ -8788,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(
         {
@@ -8808,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", {
@@ -8824,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;
 }
@@ -8878,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";
@@ -8892,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: {
@@ -9124,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;
@@ -9131,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") {
@@ -9155,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;
@@ -9200,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;
@@ -9212,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,
@@ -9322,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();
@@ -9469,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;
@@ -9517,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) {
@@ -9582,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);
@@ -9625,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;
@@ -10416,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;
@@ -10527,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;
     }
@@ -10541,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;
@@ -10587,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;
@@ -14908,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
@@ -14935,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(
@@ -14956,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;
@@ -14968,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;
@@ -15025,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;
   }
@@ -15044,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");
@@ -15124,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 [];
@@ -15153,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) {