@khalilgharbaoui/opencode-claude-code-plugin 0.15.4 → 0.16.0

package/dist/index.js

@@ -440,10 +440,35 @@ function cliSupportsThinking(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 0, patch: 0 });
 }
+var flagSupport = /* @__PURE__ */ new Map();
+function detectCliSupportsFlag(cliPath, flag) {
+  const key = `${cliPath}\0${flag}`;
+  const cached = flagSupport.get(key);
+  if (cached) return cached;
+  const promise = (async () => {
+    try {
+      const { stdout } = await execFileAsync(cliPath, ["--help"], {
+        timeout: 5e3,
+        maxBuffer: 4 * 1024 * 1024
+      });
+      return stdout.includes(flag);
+    } catch (err) {
+      log.warn("failed to probe claude cli flag support", {
+        cliPath,
+        flag,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  })();
+  flagSupport.set(key, promise);
+  return promise;
+}
 
 // src/session-manager.ts
 import { spawn } from "child_process";
 import { createInterface } from "readline";
+import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
 import { unlink } from "fs/promises";
 
@@ -932,12 +957,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         });
         let timer = null;
         const result = await new Promise(
-          (resolve4, reject2) => {
+          (resolve5, reject2) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve4,
+              resolve: resolve5,
               reject: reject2,
               channel
             };
@@ -1019,11 +1044,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       }
     }
   });
-  await new Promise((resolve4, reject2) => {
+  await new Promise((resolve5, reject2) => {
     server2.once("error", reject2);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject2);
-      resolve4();
+      resolve5();
     });
   });
   const addr = server2.address();
@@ -1077,8 +1102,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         entry.reject(new Error(SERVER_CLOSED_MESSAGE));
       }
       pending.clear();
-      await new Promise((resolve4) => {
-        server2.close(() => resolve4());
+      await new Promise((resolve5) => {
+        server2.close(() => resolve5());
       });
       if (configFilePath) {
         try {
@@ -1136,10 +1161,10 @@ function resolveDisallowedTools(options) {
   return out;
 }
 function readBody(req) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -1621,7 +1646,7 @@ async function requestSideQuestion(activeProcess, question, options) {
     }
   });
   pendingProcesses.add(proc);
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const event = `side-question:${requestId}`;
     let settled = false;
     let sent = false;
@@ -1676,7 +1701,7 @@ async function requestSideQuestion(activeProcess, question, options) {
       }
       settled = true;
       cleanup();
-      resolve4({ response: result.response, synthetic: result.synthetic });
+      resolve5({ response: result.response, synthetic: result.synthetic });
     };
     const timer = setTimeout(() => {
       fail(new Error(`/btw timed out after ${timeoutMs}ms.`), true);
@@ -1731,6 +1756,8 @@ function takeUnattendedLines(ap) {
 }
 var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
+var idleEvictionTimers = /* @__PURE__ */ new Map();
+var MAX_IDLE_TIMEOUT_MS = 2147483647;
 var MAX_ACTIVE_PROCESSES = 16;
 var PROCESS_EXIT_TIMEOUT_MS = 1500;
 var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
@@ -1778,15 +1805,107 @@ function evictIfNeeded() {
     deleteActiveProcess(oldestKey);
   }
 }
+var TURN_INTERRUPT_TIMEOUT_MS = 5e3;
+function isTerminalResultLine(line) {
+  if (!line.includes('"result"')) return false;
+  try {
+    return JSON.parse(line).type === "result";
+  } catch {
+    return false;
+  }
+}
+function settleTurn(ap) {
+  ap.turnInFlight = false;
+  const waiters = ap.turnIdleWaiters ?? [];
+  ap.turnIdleWaiters = [];
+  for (const wake of waiters) wake();
+}
+function noteTurnStarted(ap) {
+  if (ap.asideTransport?.interactive) return;
+  ap.turnInFlight = true;
+}
+function noteTurnLine(ap, line) {
+  if (!ap.turnInFlight) return;
+  if (isTerminalResultLine(line)) settleTurn(ap);
+}
+function isTurnInFlight(ap) {
+  return ap.turnInFlight === true;
+}
+function awaitTurnIdle(ap, timeoutMs) {
+  if (!ap.turnInFlight) return Promise.resolve(true);
+  return new Promise((resolve5) => {
+    const wake = () => {
+      clearTimeout(timer);
+      resolve5(true);
+    };
+    const timer = setTimeout(() => {
+      const waiters = ap.turnIdleWaiters ?? [];
+      const at = waiters.indexOf(wake);
+      if (at >= 0) waiters.splice(at, 1);
+      resolve5(false);
+    }, timeoutMs);
+    (ap.turnIdleWaiters ??= []).push(wake);
+  });
+}
+function interruptTurn(ap, timeoutMs = TURN_INTERRUPT_TIMEOUT_MS) {
+  if (!ap.turnInFlight) return Promise.resolve(true);
+  const stdin = ap.proc.stdin;
+  if (ap.asideTransport?.interactive || !stdin || !stdin.writable) {
+    log.notice("cannot interrupt this transport; waiting for the turn to end");
+    return awaitTurnIdle(ap, timeoutMs);
+  }
+  try {
+    stdin.write(
+      JSON.stringify({
+        type: "control_request",
+        request_id: randomUUID3(),
+        request: { subtype: "interrupt" }
+      }) + "\n"
+    );
+  } catch (error) {
+    log.warn("failed to write interrupt control request", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return Promise.resolve(false);
+  }
+  return awaitTurnIdle(ap, timeoutMs);
+}
+function cancelIdleProcessEviction(key) {
+  const timer = idleEvictionTimers.get(key);
+  if (!timer) return;
+  clearTimeout(timer);
+  idleEvictionTimers.delete(key);
+}
 function getActiveProcess(key) {
   const ap = activeProcesses.get(key);
-  if (ap) touch(key);
+  if (ap) {
+    cancelIdleProcessEviction(key);
+    touch(key);
+  }
   return ap;
 }
 function setActiveProcess(key, ap) {
+  cancelIdleProcessEviction(key);
   activeProcesses.set(key, ap);
 }
+function scheduleIdleProcessEviction(key, timeoutMs) {
+  cancelIdleProcessEviction(key);
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_IDLE_TIMEOUT_MS) {
+    return;
+  }
+  const scheduledProcess = activeProcesses.get(key);
+  if (!scheduledProcess) return;
+  const timer = setTimeout(() => {
+    idleEvictionTimers.delete(key);
+    if (activeProcesses.get(key) !== scheduledProcess) return;
+    log.info("evicting idle claude process", { sessionKey: key, timeoutMs });
+    deleteActiveProcess(key);
+  }, timeoutMs);
+  timer.unref();
+  idleEvictionTimers.set(key, timer);
+}
 function detachActiveProcess(key) {
+  cancelIdleProcessEviction(key);
   const ap = activeProcesses.get(key);
   if (!ap) return void 0;
   activeProcesses.delete(key);
@@ -1802,14 +1921,14 @@ function hasProcessExited(proc) {
 }
 function waitForProcessExit(proc, timeoutMs) {
   if (hasProcessExited(proc)) return Promise.resolve(true);
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const onExit = () => {
       clearTimeout(timer);
-      resolve4(true);
+      resolve5(true);
     };
     const timer = setTimeout(() => {
       proc.off("exit", onExit);
-      resolve4(hasProcessExited(proc));
+      resolve5(hasProcessExited(proc));
     }, timeoutMs);
     proc.once("exit", onExit);
   });
@@ -1905,6 +2024,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   const rl = createInterface({ input: proc.stdout });
   rl.on("line", (line) => {
     if (dispatchSideQuestionResponse(ap, line)) return;
+    noteTurnLine(ap, line);
     if (lineEmitter.listenerCount("line") === 0) {
       bufferUnattendedLine(ap, line);
       return;
@@ -1912,8 +2032,10 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     lineEmitter.emit("line", line);
   });
   rl.on("close", () => {
+    settleTurn(ap);
     lineEmitter.emit("close");
   });
+  cancelIdleProcessEviction(sessionKey2);
   activeProcesses.set(sessionKey2, ap);
   proc.on("error", (err) => {
     log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
@@ -1926,7 +2048,10 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
       });
     }
     const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
-    if (ownsSessionKey) activeProcesses.delete(sessionKey2);
+    if (ownsSessionKey) {
+      cancelIdleProcessEviction(sessionKey2);
+      activeProcesses.delete(sessionKey2);
+    }
     if (ownsSessionKey && code !== 0 && code !== null) {
       log.info("process exited with error, clearing session", {
         code,
@@ -1997,6 +2122,7 @@ function buildCliArgs(opts) {
     strictMcpConfig,
     disallowedTools,
     appendSystemPromptFile,
+    pluginDirs,
     thinking,
     thinkingDisplay,
     fastMode,
@@ -2045,6 +2171,9 @@ function buildCliArgs(opts) {
   if (appendSystemPromptFile) {
     args.push("--append-system-prompt-file", appendSystemPromptFile);
   }
+  for (const dir of pluginDirs ?? []) {
+    args.push("--plugin-dir", dir);
+  }
   if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
     args.push("--settings", JSON.stringify({ fastMode: true }));
   }
@@ -2169,7 +2298,7 @@ async function waitForSessionIdle(client, sessionID, options = {}) {
     if (options.stop?.()) return true;
     if (await sessionStatus(client, sessionID) !== "busy") return true;
     if (Date.now() - started >= timeoutMs) return false;
-    await new Promise((resolve4) => setTimeout(resolve4, pollMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
   }
 }
 async function deliverAsideInline(client, sessionID, text, options = {}) {
@@ -2180,7 +2309,7 @@ async function deliverAsideInline(client, sessionID, text, options = {}) {
     if (emitAsideInline(sessionID, text)) return true;
     if (Date.now() - started >= timeoutMs) return false;
     if (await sessionStatus(client, sessionID) !== "busy") return false;
-    await new Promise((resolve4) => setTimeout(resolve4, pollMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
   }
 }
 async function waitForAsideProcess(client, sessionID, options = {}) {
@@ -2201,7 +2330,7 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
       log.warn("btw: a turn is running but no claude process appeared for it", { sessionID, waitedMs });
       return void 0;
     }
-    await new Promise((resolve4) => setTimeout(resolve4, pollMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
   }
 }
 async function settleSessionBusy(client, sessionID, active, options = {}) {
@@ -2213,7 +2342,7 @@ async function settleSessionBusy(client, sessionID, active, options = {}) {
     if (status === "busy") return true;
     if (status === "unknown") return isProcessBusy(active);
     if (Date.now() - started >= settleMs) return false;
-    await new Promise((resolve4) => setTimeout(resolve4, pollMs));
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
   }
 }
 function errorText(error) {
@@ -2260,10 +2389,10 @@ async function handleBtwCommand(client, input, options = {}) {
   let inlineDone = false;
   let markInlineDelivered = () => {
   };
-  const inlineDelivered = new Promise((resolve4) => {
+  const inlineDelivered = new Promise((resolve5) => {
     markInlineDelivered = () => {
       inlineDone = true;
-      resolve4("inline");
+      resolve5("inline");
     };
   });
   if (isSideQuestionPending(active)) {
@@ -3093,34 +3222,166 @@ function agentDirectories(home, projectDirectory) {
   return directories;
 }
 
-// src/mcp-bridge.ts
+// src/skill-bridge.ts
+import * as crypto2 from "crypto";
 import * as fs3 from "fs";
-import * as path4 from "path";
 import * as os2 from "os";
-import * as crypto2 from "crypto";
+import * as path4 from "path";
+var SKILL_PLUGIN_NAME = "opencode-skills";
+function dirExists(p) {
+  try {
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function fileExists(p) {
+  try {
+    return fs3.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function skillRoots(cwd) {
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const abs = path4.resolve(p);
+    if (seen.has(abs)) return;
+    seen.add(abs);
+    if (dirExists(abs)) roots.push(abs);
+  };
+  let current = path4.resolve(cwd);
+  while (true) {
+    push(path4.join(current, ".opencode", "skills"));
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  const home = os2.homedir();
+  if (home) push(path4.join(home, ".opencode", "skills"));
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir) push(path4.join(envDir, "skills"));
+  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path4.join(home, ".config") : null);
+  if (xdg) push(path4.join(xdg, "opencode", "skills"));
+  return roots;
+}
+function discoverOpencodeSkills(cwd) {
+  const found = [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const root of skillRoots(cwd)) {
+    let entries;
+    try {
+      entries = fs3.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      const name = entry.name;
+      if (name.startsWith(".")) continue;
+      if (claimed.has(name)) continue;
+      const dir = path4.join(root, name);
+      if (!fileExists(path4.join(dir, "SKILL.md"))) continue;
+      claimed.add(name);
+      found.push({ name, dir });
+    }
+  }
+  return found.sort((a, b) => a.name.localeCompare(b.name));
+}
+function linkSkill(source, target) {
+  try {
+    fs3.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+    return;
+  } catch {
+    fs3.cpSync(source, target, { recursive: true, dereference: true });
+  }
+}
+function buildSkillPluginDir(skills) {
+  if (skills.length === 0) return null;
+  const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
+  const hash = crypto2.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
+  const root = path4.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path4.join(root, ".claude-plugin", "plugin.json");
+  if (fileExists(manifest)) return root;
+  try {
+    fs3.rmSync(root, { recursive: true, force: true });
+    fs3.mkdirSync(path4.join(root, ".claude-plugin"), { recursive: true });
+    fs3.mkdirSync(path4.join(root, "skills"), { recursive: true });
+    fs3.writeFileSync(
+      manifest,
+      JSON.stringify(
+        {
+          name: SKILL_PLUGIN_NAME,
+          description: "Skills discovered from this opencode installation, bridged into Claude Code."
+        },
+        null,
+        2
+      ),
+      { encoding: "utf8", mode: 384 }
+    );
+    for (const skill of skills) {
+      linkSkill(skill.dir, path4.join(root, "skills", skill.name));
+    }
+  } catch (err) {
+    log.warn("failed to stage opencode skill plugin dir", {
+      root,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+  return root;
+}
+async function resolveSkillPluginDirs(opts) {
+  if (!opts.enabled) return [];
+  const skills = discoverOpencodeSkills(opts.cwd);
+  if (skills.length === 0) return [];
+  const supported = await detectCliSupportsFlag(opts.cliPath, "--plugin-dir");
+  if (!supported) {
+    log.notice(
+      "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
+      { skills: skills.length }
+    );
+    return [];
+  }
+  const dir = buildSkillPluginDir(skills);
+  if (!dir) return [];
+  log.info("bridged opencode skills into claude", {
+    count: skills.length,
+    names: skills.map((s) => s.name),
+    pluginDir: dir
+  });
+  return [dir];
+}
+
+// src/mcp-bridge.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
+import * as crypto3 from "crypto";
 import {
   parse as parseJsonc,
   printParseErrorCode
 } from "jsonc-parser";
 var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
 var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
-function fileExists(p) {
+function fileExists2(p) {
   try {
-    return fs3.statSync(p).isFile();
+    return fs4.statSync(p).isFile();
   } catch {
     return false;
   }
 }
-function dirExists(p) {
+function dirExists2(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) {
@@ -3156,14 +3417,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;
   }
@@ -3171,29 +3432,29 @@ 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(os3.homedir(), ".config");
+  return path5.join(xdg, "opencode");
 }
 function loadGlobalConfig() {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path4.join(dir, name);
-    if (!fileExists(file)) continue;
+    const file = path5.join(dir, name);
+    if (!fileExists2(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
   }
@@ -3202,8 +3463,8 @@ function loadGlobalConfig() {
 function loadProjectFilesInDir(dir) {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path4.join(dir, name);
-    if (!fileExists(file)) continue;
+    const file = path5.join(dir, name);
+    if (!fileExists2(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
   }
@@ -3213,8 +3474,8 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path4.resolve(p);
-    if (!seen.has(abs) && dirExists(abs)) {
+    const abs = path5.resolve(p);
+    if (!seen.has(abs) && dirExists2(abs)) {
       seen.add(abs);
       dirs.push(abs);
     }
@@ -3223,17 +3484,17 @@ function dotOpencodeDirs(cwd, worktree) {
     start: cwd,
     stop: worktree,
     targets: [".opencode"],
-    predicate: dirExists
+    predicate: dirExists2
   })) {
     push(dir);
   }
-  const home = os2.homedir();
+  const home = os3.homedir();
   if (home) {
-    const homeDot = path4.join(home, ".opencode");
-    if (dirExists(homeDot)) push(homeDot);
+    const homeDot = path5.join(home, ".opencode");
+    if (dirExists2(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir && dirExists(envDir)) push(envDir);
+  if (envDir && dirExists2(envDir)) push(envDir);
   return dirs;
 }
 function substituteEnvPlaceholders(source) {
@@ -3341,7 +3602,7 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
   let merged = {};
   merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
   const explicitConfig = process.env.OPENCODE_CONFIG;
-  if (explicitConfig && fileExists(explicitConfig)) {
+  if (explicitConfig && fileExists2(explicitConfig)) {
     const parsed = readAndParse(explicitConfig);
     if (parsed) merged = mergeMcp(merged, extractMcpBlock(parsed));
   }
@@ -3349,12 +3610,12 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
     start: cwd,
     stop: worktree,
     targets: PROJECT_FILE_NAMES,
-    predicate: fileExists
+    predicate: fileExists2
   });
   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);
@@ -3383,7 +3644,7 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
     enabledServerNames.push(name);
   }
   const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
-  const hash = crypto2.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  const hash = crypto3.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
   return { servers: merged, enabledServerNames, hash };
 }
 function finishBridge(input) {
@@ -3399,13 +3660,13 @@ function finishBridge(input) {
     };
   }
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const outPath = path4.join(
+  const outPath = path5.join(
     pluginTmpDir(),
     `mcp-${hash}.json`
   );
   try {
-    if (!fileExists(outPath)) {
-      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+    if (!fileExists2(outPath)) {
+      fs4.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
     }
   } catch (e) {
     log.warn("failed to write bridged MCP config", {
@@ -3447,17 +3708,39 @@ function getOpencodeProjectDirectory() {
 function isUsableDirectory(d) {
   return typeof d === "string" && d.length > 1 && d !== "/";
 }
-function resolveSpawnCwd(configured) {
+function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
+  if (configured) return configured;
+  if (isUsableDirectory(sessionDir)) return sessionDir;
+  if (isUsableDirectory(live)) return live;
+  return captured ?? live;
+}
+async function resolveSpawnCwdForSession(configured, sessionID) {
+  if (configured) return configured;
+  const sessionDir = sessionID ? await fetchSessionDirectory(sessionID) : void 0;
   return resolveSpawnCwdFrom(
     configured,
     process.cwd(),
-    opencodeProjectDirectory
+    opencodeProjectDirectory,
+    sessionDir
   );
 }
-function resolveSpawnCwdFrom(configured, live, captured) {
-  if (configured) return configured;
-  if (isUsableDirectory(live)) return live;
-  return captured ?? live;
+async function fetchSessionDirectory(sessionID) {
+  if (!sessionID || sessionID === "default") return void 0;
+  const client = opencodeClient;
+  if (!client?.session?.get) return void 0;
+  try {
+    const res = await client.session.get({ path: { id: sessionID } });
+    const data = res.data;
+    if (!data || typeof data !== "object") return void 0;
+    const dir = data.directory;
+    return isUsableDirectory(dir) ? dir : void 0;
+  } catch (err) {
+    log.warn("failed to fetch opencode session directory", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
 }
 async function getRuntimeMcpStatus() {
   const client = opencodeClient;
@@ -3516,40 +3799,40 @@ import { EventEmitter as EventEmitter4 } from "events";
 import { unlink as unlink2 } from "fs/promises";
 
 // src/claude-session-bun.ts
-import * as os3 from "os";
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as os4 from "os";
+import * as fs5 from "fs";
+import * as path6 from "path";
 import { execFileSync } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function resolveClaude(cmd = "claude") {
-  if (path5.isAbsolute(cmd) && fs4.existsSync(cmd)) return cmd;
+  if (path6.isAbsolute(cmd) && fs5.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
-  const isWin = os3.platform() === "win32";
+  const isWin = os4.platform() === "win32";
   try {
     const out = execFileSync(isWin ? "where" : "which", [cmd], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs4.existsSync(p));
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs5.existsSync(p));
     if (first) return first;
   } catch {
   }
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  return path5.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+  return path6.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
 }
 var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path5.join(os3.homedir(), ".claude");
-  if (value === "~") return os3.homedir();
+  if (!value) return path6.join(os4.homedir(), ".claude");
+  if (value === "~") return os4.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path5.join(os3.homedir(), value.slice(2));
+    return path6.join(os4.homedir(), value.slice(2));
   }
-  return path5.resolve(value);
+  return path6.resolve(value);
 }
 var ClaudeSession = class {
   sessionId;
@@ -3567,11 +3850,11 @@ var ClaudeSession = class {
   signal;
   o;
   constructor(opts = {}) {
-    this.cwd = path5.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path6.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.signal = opts.signal;
-    this.sessionId = randomUUID3();
-    this.jsonlPath = path5.join(
+    this.sessionId = randomUUID4();
+    this.jsonlPath = path6.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
@@ -3694,7 +3977,7 @@ var ClaudeSession = class {
   }
   readRawLines() {
     try {
-      return fs4.readFileSync(this.jsonlPath, "utf8").split("\n");
+      return fs5.readFileSync(this.jsonlPath, "utf8").split("\n");
     } catch {
       return [];
     }
@@ -4072,11 +4355,11 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/claude-code-language-model.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
-import { randomUUID as randomUUID4 } from "crypto";
-import { dirname as dirname3, join as join6 } from "path";
+import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
+import { randomUUID as randomUUID5 } from "crypto";
+import { dirname as dirname4, join as join7 } from "path";
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
   const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
@@ -4283,9 +4566,9 @@ ${body}`;
     }
   });
 }
-function readPromptFileIfPresent(path8) {
+function readPromptFileIfPresent(path9) {
   try {
-    const content = readFileSync3(path8, "utf8").trim();
+    const content = readFileSync3(path9, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -4294,9 +4577,9 @@ function readPromptFileIfPresent(path8) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join6(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join7(dir, "AGENTS.md"));
     if (content) return content;
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -4379,19 +4662,22 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join6(homedir4(), ".config");
-  const globalAgents = readPromptFileIfPresent(join6(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join7(homedir5(), ".config");
+  const globalAgents = readPromptFileIfPresent(join7(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
-  if (globalAgents) parts.push(globalAgents);
-  if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
-  if (globalAgents || workspaceAgents) parts.push(AGENTS_MAINTENANCE_HINT);
+  const forwarded = extraSystemContent.join("\n\n");
+  const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
+  const pushWorkspace = !!workspaceAgents && workspaceAgents !== globalAgents && !forwarded.includes(workspaceAgents);
+  if (pushGlobal) parts.push(globalAgents);
+  if (pushWorkspace) parts.push(workspaceAgents);
+  if (pushGlobal || pushWorkspace) parts.push(AGENTS_MAINTENANCE_HINT);
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path8 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID4()}.md`);
+  const path9 = join7(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    writeFileSync3(path8, content, "utf8");
-    return path8;
+    writeFileSync4(path9, content, "utf8");
+    return path9;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -4972,9 +5258,9 @@ var ClaudeCodeLanguageModel = class {
       return this.doGenerateViaStream(options);
     }
     const warnings = [];
-    const cwd = resolveSpawnCwd(this.config.cwd);
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
+    const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const effectiveModelId = resolveAgentModel(
       this.getOpencodeAgent(options.providerOptions),
       this.modelId
@@ -5113,7 +5399,7 @@ var ClaudeCodeLanguageModel = class {
     const toolCalls = [];
     const toolCallStreams = /* @__PURE__ */ new Map();
     let gotPartialEvents = false;
-    const result = await new Promise((resolve4, reject) => {
+    const result = await new Promise((resolve5, reject) => {
       const cleanup = () => {
         try {
           if (!proc.killed && proc.exitCode === null) proc.kill();
@@ -5248,7 +5534,7 @@ ${plan}
               usage: msg.usage
             };
             cleanup();
-            resolve4({
+            resolve5({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -5260,7 +5546,7 @@ ${plan}
       });
       rl.on("close", () => {
         cleanup();
-        resolve4({
+        resolve5({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -5366,11 +5652,11 @@ ${plan}
   }
   async doStream(options) {
     const warnings = [];
-    const cwd = resolveSpawnCwd(this.config.cwd);
     const cliPath = this.config.cliPath;
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
+    const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const compactionMode = this.isCompactionCall(options);
     const effectiveModelId = compactionMode ? this.resolveCompactionModel() : resolveAgentModel(
       this.getOpencodeAgent(options.providerOptions),
@@ -5743,6 +6029,11 @@ ${plan}
                   compressionSummary: getCompressionSummary(sk)
                 }
               );
+              const skillPluginDirs = await resolveSkillPluginDirs({
+                cwd,
+                cliPath,
+                enabled: self.config.bridgeOpencodeSkills === true
+              });
               cliArgs = buildCliArgs({
                 sessionKey: sk,
                 skipPermissions,
@@ -5752,6 +6043,7 @@ ${plan}
                 strictMcpConfig: self.config.strictMcpConfig,
                 disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
                 appendSystemPromptFile: systemPromptFile,
+                pluginDirs: skillPluginDirs,
                 ...self.thinkingCliOptions(),
                 fastMode,
                 cliVersion
@@ -5781,6 +6073,13 @@ ${plan}
               activeProcess = ap;
             }
           }
+          if (activeProcess && !hasMatchedPendingResults && isTurnInFlight(activeProcess)) {
+            log.warn("previous turn still in flight; interrupting it", { sk });
+            const idle = await interruptTurn(activeProcess);
+            if (!idle) {
+              log.warn("previous turn did not stop in time; this turn may see stale output", { sk });
+            }
+          }
           controller.enqueue({ type: "stream-start", warnings });
           let currentTextId = null;
           const textBlockIndices = /* @__PURE__ */ new Set();
@@ -5919,7 +6218,10 @@ ${plan}
             lineEmitter.on("close", closeHandler);
             proc.on("error", procErrorHandler);
             try {
-              if (!deliverPendingCompletions(true)) proc.stdin?.write(watchdogMessage + "\n");
+              if (!deliverPendingCompletions(true)) {
+                noteTurnStarted(newAp);
+                proc.stdin?.write(watchdogMessage + "\n");
+              }
               log.debug("re-sent user message after respawn", {
                 textLength: watchdogMessage.length
               });
@@ -6146,6 +6448,7 @@ ${plan}
               });
               turnCompleted = false;
               resetAutoContinueWindow();
+              if (activeProcess) noteTurnStarted(activeProcess);
               proc.stdin?.write(makeAutoContinueMessage() + "\n");
               return;
             }
@@ -6186,6 +6489,9 @@ ${plan}
             });
             controllerClosed = true;
             cleanupTurn();
+            if (!useInteractive && !compactionMode) {
+              scheduleIdleProcessEviction(sk, self.config.idleProcessTimeoutMs);
+            }
             try {
               controller.close();
             } catch {
@@ -6952,6 +7258,11 @@ ${plan}
             options.abortSignal.addEventListener("abort", () => {
               autoContinueState.aborted = true;
               if (turnCompleted || controllerClosed) return;
+              if (activeProcess) {
+                void interruptTurn(activeProcess).then((idle) => {
+                  log.info("interrupt sent for aborted turn", { sk, idle });
+                });
+              }
               if (!hasReceivedContent) {
                 log.info(
                   "abort signal received before content, closing stream immediately",
@@ -7039,6 +7350,7 @@ ${plan}
               );
             }
           }
+          if (activeProcess) noteTurnStarted(activeProcess);
           proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
           armStartWatchdog();
@@ -7070,7 +7382,7 @@ ${plan}
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -7108,7 +7420,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path6.join(home, value.slice(2)) : value;
+    return home ? path7.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -7140,8 +7452,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path6.join(sourceRoot, item);
-  const target = path6.join(targetRoot, item);
+  const source = path7.join(sourceRoot, item);
+  const target = path7.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -7152,8 +7464,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path6.resolve(path6.dirname(target), current);
-      const resolvedSource = path6.resolve(source);
+      const resolvedCurrent = path7.resolve(path7.dirname(target), current);
+      const resolvedSource = path7.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -7168,11 +7480,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path6.join(
+  const cacheRoot = path7.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path6.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path7.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -7215,11 +7527,11 @@ import {
   existsSync as existsSync4,
   readFileSync as readFileSync4,
   realpathSync,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync4
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join7, resolve as resolve3 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join8, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -7227,14 +7539,14 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join7(xdg, "opencode") : null,
-    join7(homedir5(), ".cache", "opencode"),
-    join7(homedir5(), "Library", "Caches", "opencode")
+    xdg ? join8(xdg, "opencode") : null,
+    join8(homedir6(), ".cache", "opencode"),
+    join8(homedir6(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join7(homedir5(), ".config");
-  return join7(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
+  return join8(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
@@ -7253,7 +7565,7 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath(import.meta.url);
-    return realpathSync(resolve3(filePath, "..", ".."));
+    return realpathSync(resolve4(filePath, "..", ".."));
   } catch {
     return null;
   }
@@ -7277,7 +7589,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync4(cacheRoot)) return;
-  const stalePath = join7(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join8(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync4(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -7285,7 +7597,7 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join7(stalePath, "package.json");
+  const pkgJsonPath = join8(stalePath, "package.json");
   if (!existsSync4(pkgJsonPath)) return;
   let pkg = {};
   try {
@@ -7297,7 +7609,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!pkg.description?.includes(SUSPECT_DESCRIPTION_TOKEN)) return;
   log.info("cleanup-stale: removing unscoped install", { stalePath });
   try {
-    rmSync2(stalePath, { recursive: true, force: true });
+    rmSync3(stalePath, { recursive: true, force: true });
   } catch (err) {
     log.warn("cleanup-stale: rmSync failed", {
       stalePath,
@@ -7305,13 +7617,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join7(cacheRoot, "package.json");
+  const cachePkgJson = join8(cacheRoot, "package.json");
   if (!existsSync4(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync4(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync4(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync5(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -7323,16 +7635,16 @@ function cleanupOne(cacheRoot, ourDir) {
 
 // src/startup-diagnostics.ts
 import { execFile as execFile2 } from "child_process";
-import * as fs5 from "fs";
-import * as path7 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
 import { promisify as promisify2 } from "util";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path7.dirname(fileURLToPath2(import.meta.url));
-    const raw = fs5.readFileSync(path7.join(here, "..", "package.json"), "utf8");
+    const here = path8.dirname(fileURLToPath2(import.meta.url));
+    const raw = fs6.readFileSync(path8.join(here, "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     cachedPluginVersion = typeof version === "string" ? version : "unknown";
   } catch {
@@ -7356,7 +7668,7 @@ var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
   opencodeVersionProbe = (async () => {
-    if (!path7.basename(execPath).toLowerCase().includes("opencode")) {
+    if (!path8.basename(execPath).toLowerCase().includes("opencode")) {
       log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
       return void 0;
     }
@@ -7526,6 +7838,8 @@ function createClaudeCode(settings = {}) {
       autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart",
       compactionModel: settings.compactionModel,
       ignoreAnthropicApiKey: settings.ignoreAnthropicApiKey,
+      idleProcessTimeoutMs: settings.idleProcessTimeoutMs,
+      bridgeOpencodeSkills: settings.bridgeOpencodeSkills === true,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
       interactiveAllowTools: settings.interactiveAllowTools,