@khalilgharbaoui/opencode-claude-code-plugin 0.15.4 → 0.17.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";
 
@@ -498,6 +523,8 @@ var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
   task: 60 * 60 * 1e3,
   // 60 min
+  task_batch: 60 * 60 * 1e3,
+  // 60 min, same reasoning: it IS task calls
   question: 30 * 60 * 1e3
   // 30 min
 };
@@ -537,14 +564,58 @@ function resolveProxyClientCeilingMs(overrides) {
 function buildProxyTimeoutError(toolName, ms) {
   const key = toolName.toLowerCase();
   const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
-  if (key === "task") {
+  if (key === "task" || key === TASK_BATCH_TOOL_NAME) {
     return new Error(
-      base + " (the subagent). The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
+      base + (key === "task" ? " (the subagent)." : " (the subagents).") + " The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
     );
   }
   return new Error(base);
 }
-var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists \u2014 invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_BATCH_TOOL_NAME = "task_batch";
+var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Same 60-minute proxy deadline as task (configurable via proxyToolTimeoutMs).";
+var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
+function taskBatchInputError(input) {
+  const tasks = input?.tasks;
+  if (!Array.isArray(tasks) || tasks.length < 2) {
+    return "task_batch requires a `tasks` array with at least two items; use `task` for one subagent";
+  }
+  for (const [index, task] of tasks.entries()) {
+    if (task === null || typeof task !== "object" || Array.isArray(task)) {
+      return `task_batch tasks[${index}] must be an object`;
+    }
+    const item = task;
+    for (const field of TASK_INPUT_REQUIRED) {
+      if (typeof item[field] !== "string") {
+        return `task_batch tasks[${index}].${field} must be a string`;
+      }
+    }
+  }
+  return null;
+}
+function taskBatchTasks(input) {
+  if (taskBatchInputError(input)) return [];
+  return input.tasks;
+}
+function taskBatchChildToolCallId(parentToolCallId, index) {
+  return `${parentToolCallId}_task_${index}`;
+}
+function formatTaskBatchResults(children) {
+  const total = children.length;
+  const sections = children.map(({ task, result }, index) => {
+    const label = typeof task.description === "string" ? task.description : `task ${index + 1}`;
+    const agent = typeof task.subagent_type === "string" ? ` (${task.subagent_type})` : "";
+    const header = `## task ${index + 1} of ${total}: ${label}${agent}`;
+    if (!result) return `${header}
+[missing] opencode returned no result for this task in the batch`;
+    if (result.kind === "error") return `${header}
+[error] ${result.message}`;
+    return `${header}
+${result.isError ? "[error] " : ""}${result.text}`;
+  });
+  const failed = children.some(({ result }) => !result || result.kind === "error" || result.isError);
+  return { kind: "text", text: sections.join("\n\n"), ...failed ? { isError: true } : {} };
+}
 var AGENT_TYPES_HEADING = "Available agent types";
 var AGENT_BLURB_LIMIT = 140;
 var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
@@ -572,7 +643,7 @@ function overlayTaskProxyDescription(tools, liveDescription) {
   const agentTypes = extractAgentTypeList(liveDescription);
   if (!agentTypes) return tools;
   return tools.map(
-    (t) => t.name === "task" ? { ...t, description: `${agentTypes}
+    (t) => t.name === "task" || t.name === TASK_BATCH_TOOL_NAME ? { ...t, description: `${agentTypes}
 
 ${t.description}` } : t
   );
@@ -590,6 +661,32 @@ function filterQuestionProxyByOpencodeSupport(tools, opencodeHasQuestion) {
   if (opencodeHasQuestion) return tools;
   return tools.filter((t) => t.name !== "question");
 }
+var TASK_INPUT_PROPERTIES = {
+  description: {
+    type: "string",
+    description: "A short (3-5 words) description of the task"
+  },
+  prompt: {
+    type: "string",
+    description: "The task for the agent to perform"
+  },
+  subagent_type: {
+    type: "string",
+    description: "The type of specialized agent to use for this task"
+  },
+  task_id: {
+    type: "string",
+    description: "Set this only if you mean to resume a previous task: pass the prior task_id to continue the same subagent session instead of creating a fresh one."
+  },
+  command: {
+    type: "string",
+    description: "The command that triggered this task"
+  },
+  background: {
+    type: "boolean",
+    description: "Run the task in the background when supported by opencode"
+  }
+};
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -683,35 +780,30 @@ var DEFAULT_PROXY_TOOLS = [
   {
     name: "task",
     description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). " + TASK_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: TASK_INPUT_PROPERTIES,
+      required: TASK_INPUT_REQUIRED
+    }
+  },
+  {
+    name: TASK_BATCH_TOOL_NAME,
+    description: "Launch two or more independent opencode subagents at the same time and get all their results back together. Put one ordinary task input in `tasks` for each subagent. " + TASK_BATCH_PROXY_NOTE,
     inputSchema: {
       type: "object",
       properties: {
-        description: {
-          type: "string",
-          description: "A short (3-5 words) description of the task"
-        },
-        prompt: {
-          type: "string",
-          description: "The task for the agent to perform"
-        },
-        subagent_type: {
-          type: "string",
-          description: "The type of specialized agent to use for this task"
-        },
-        task_id: {
-          type: "string",
-          description: "Set this only if you mean to resume a previous task \u2014 pass the prior task_id to continue the same subagent session instead of creating a fresh one."
-        },
-        command: {
-          type: "string",
-          description: "The command that triggered this task"
-        },
-        background: {
-          type: "boolean",
-          description: "Run the task in the background when supported by opencode"
+        tasks: {
+          type: "array",
+          minItems: 2,
+          description: "Independent subagent tasks to run concurrently",
+          items: {
+            type: "object",
+            properties: TASK_INPUT_PROPERTIES,
+            required: TASK_INPUT_REQUIRED
+          }
         }
       },
-      required: ["description", "prompt", "subagent_type"]
+      required: ["tasks"]
     }
   },
   {
@@ -897,6 +989,13 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
+        if (toolName === TASK_BATCH_TOOL_NAME) {
+          const problem = taskBatchInputError(input);
+          if (problem) {
+            writeToolCallResult(res, requestId, { kind: "error", message: problem });
+            return;
+          }
+        }
         const interceptor = interceptors?.get(toolName);
         if (interceptor) {
           let intercepted;
@@ -932,12 +1031,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 +1118,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 +1176,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 {
@@ -1101,6 +1200,7 @@ function disallowedToolFlags(tools) {
     grep: ["Grep"],
     webfetch: ["WebFetch"],
     task: ["Agent"],
+    task_batch: ["Agent"],
     // `question` disables Claude Code's built-in `AskUserQuestion` so the
     // structured-questions path flows through opencode's native `question`
     // tool instead — same UI/permission/audit benefits as the other
@@ -1136,10 +1236,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 +1721,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 +1776,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 +1831,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 +1880,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 +1996,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 +2099,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 +2107,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 +2123,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 +2197,7 @@ function buildCliArgs(opts) {
     strictMcpConfig,
     disallowedTools,
     appendSystemPromptFile,
+    pluginDirs,
     thinking,
     thinkingDisplay,
     fastMode,
@@ -2045,6 +2246,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 +2373,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 +2384,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 +2405,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 +2417,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 +2464,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 +3297,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 +3492,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 +3507,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 +3538,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 +3549,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 +3559,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 +3677,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 +3685,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 +3719,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 +3735,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 +3783,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 +3874,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 +3925,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 +4052,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 +4430,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 +4641,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 +4652,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;
   }
@@ -4316,8 +4674,9 @@ blocker. The user can interrupt or abort at any time; turn endings should
 mark meaningful checkpoints, not every completed substep.`;
 var SUBAGENT_DISPATCH_HINT = `## opencode subagents
 
-Subagent dispatch in this environment goes through exactly one tool: \`mcp__opencode_proxy__task\`.
+Subagent dispatch in this environment goes through exactly two tools: \`mcp__opencode_proxy__task\` for one subagent and \`mcp__opencode_proxy__task_batch\` for two or more at once.
 
+- Two or more independent subagents in one response: make ONE \`mcp__opencode_proxy__task_batch\` call with a \`tasks\` array (each item is a normal task input). Claude Code runs MCP calls one at a time, so several \`mcp__opencode_proxy__task\` calls in the same response run serially; \`task_batch\` runs them concurrently in opencode and returns every result together, labelled in order.
 - When the user mentions \`@<agent>\` or an instruction says "call the task tool with subagent: <name>", call \`mcp__opencode_proxy__task\` with \`subagent_type: "<name>"\`.
 - If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__task\`), then call it.
 - Claude Code's built-in TaskCreate/TaskUpdate/TaskList manage a local todo list. They cannot dispatch subagents; creating a task there runs nothing. Never report a subagent as dispatched unless \`mcp__opencode_proxy__task\` returned its result.
@@ -4379,19 +4738,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;
@@ -4518,11 +4880,24 @@ var ClaudeCodeLanguageModel = class {
       DEFAULT_PROXY_TOOLS.map((t) => [t.name.toLowerCase(), t])
     );
     const picked = [];
+    const seen = /* @__PURE__ */ new Set();
     const unknown = [];
+    const pick = (def) => {
+      if (seen.has(def.name)) return;
+      seen.add(def.name);
+      picked.push(def);
+    };
     for (const n of names) {
       const def = defsByName.get(String(n).toLowerCase());
-      if (def) picked.push(def);
-      else unknown.push(String(n));
+      if (!def) {
+        unknown.push(String(n));
+        continue;
+      }
+      pick(def);
+      if (def.name === "task") {
+        const batch = defsByName.get(TASK_BATCH_TOOL_NAME);
+        if (batch) pick(batch);
+      }
     }
     if (unknown.length > 0) {
       const known = [...defsByName.keys()].join(", ");
@@ -4712,6 +5087,41 @@ var ClaudeCodeLanguageModel = class {
     }
     return null;
   }
+  /**
+   * The result opencode produced for a pending proxy call, if the prompt
+   * carries it. For `task_batch` that means every child's result gathered
+   * back onto the parent: opencode runs the children in one step and hands
+   * all their results to the next call together, so a partial set is not
+   * expected. If it ever happens the batch still resolves, with the gap
+   * named in the text, because leaving the parent pending would send this
+   * turn down the fresh-envelope path and reject the call as orphaned.
+   */
+  extractPendingProxyResultForCall(prompt, call) {
+    if (call.toolName !== TASK_BATCH_TOOL_NAME) {
+      return this.extractPendingProxyResult(prompt, call.toolCallId);
+    }
+    const tasks = taskBatchTasks(call.input);
+    if (tasks.length === 0) {
+      return { kind: "error", message: "task_batch input is not a list of task objects" };
+    }
+    const children = tasks.map((task, index) => ({
+      task,
+      result: this.extractPendingProxyResult(
+        prompt,
+        taskBatchChildToolCallId(call.toolCallId, index)
+      )
+    }));
+    const answered = children.filter((child) => child.result !== null).length;
+    if (answered === 0) return null;
+    if (answered < children.length) {
+      log.warn("task_batch resolving with child results missing", {
+        toolCallId: call.toolCallId,
+        answered,
+        total: children.length
+      });
+    }
+    return formatTaskBatchResults(children);
+  }
   /**
    * Resolve the session affinity token for this LLM call. Delegates to the
    * exported `resolveSessionAffinity` helper so the logic is unit-testable.
@@ -4972,9 +5382,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 +5523,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 +5658,7 @@ ${plan}
               usage: msg.usage
             };
             cleanup();
-            resolve4({
+            resolve5({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -5260,7 +5670,7 @@ ${plan}
       });
       rl.on("close", () => {
         cleanup();
-        resolve4({
+        resolve5({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -5366,11 +5776,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),
@@ -5523,7 +5933,7 @@ ${plan}
     const self = this;
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
       call,
-      result: this.extractPendingProxyResult(options.prompt, call.toolCallId)
+      result: this.extractPendingProxyResultForCall(options.prompt, call)
     }));
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
@@ -5743,6 +6153,11 @@ ${plan}
                   compressionSummary: getCompressionSummary(sk)
                 }
               );
+              const skillPluginDirs = await resolveSkillPluginDirs({
+                cwd,
+                cliPath,
+                enabled: self.config.bridgeOpencodeSkills === true
+              });
               cliArgs = buildCliArgs({
                 sessionKey: sk,
                 skipPermissions,
@@ -5752,6 +6167,7 @@ ${plan}
                 strictMcpConfig: self.config.strictMcpConfig,
                 disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
                 appendSystemPromptFile: systemPromptFile,
+                pluginDirs: skillPluginDirs,
                 ...self.thinkingCliOptions(),
                 fastMode,
                 cliVersion
@@ -5781,6 +6197,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 +6342,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
               });
@@ -5969,20 +6395,34 @@ ${plan}
           const finishWithToolCalls = (calls) => {
             if (controllerClosed) return;
             if (calls.length === 0) return;
-            for (const call of calls) {
+            const enqueueToolCall = (toolCallId, toolName, input) => {
               controller.enqueue({
                 type: "tool-input-start",
-                id: call.toolCallId,
-                toolName: call.toolName
+                id: toolCallId,
+                toolName
               });
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                input: JSON.stringify(call.input),
+                toolCallId,
+                toolName,
+                input: JSON.stringify(input),
                 providerExecuted: false
               });
-              skipResultForIds.add(call.toolCallId);
+              skipResultForIds.add(toolCallId);
+            };
+            for (const call of calls) {
+              if (call.toolName === TASK_BATCH_TOOL_NAME) {
+                for (const [index, task] of taskBatchTasks(call.input).entries()) {
+                  enqueueToolCall(
+                    taskBatchChildToolCallId(call.toolCallId, index),
+                    "task",
+                    task
+                  );
+                }
+                skipResultForIds.add(call.toolCallId);
+              } else {
+                enqueueToolCall(call.toolCallId, call.toolName, call.input);
+              }
               markPendingProxyCallEmitted(call.toolCallId);
             }
             controller.enqueue({
@@ -6146,6 +6586,7 @@ ${plan}
               });
               turnCompleted = false;
               resetAutoContinueWindow();
+              if (activeProcess) noteTurnStarted(activeProcess);
               proc.stdin?.write(makeAutoContinueMessage() + "\n");
               return;
             }
@@ -6186,6 +6627,9 @@ ${plan}
             });
             controllerClosed = true;
             cleanupTurn();
+            if (!useInteractive && !compactionMode) {
+              scheduleIdleProcessEviction(sk, self.config.idleProcessTimeoutMs);
+            }
             try {
               controller.close();
             } catch {
@@ -6952,6 +7396,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 +7488,7 @@ ${plan}
               );
             }
           }
+          if (activeProcess) noteTurnStarted(activeProcess);
           proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
           armStartWatchdog();
@@ -7070,7 +7520,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 +7558,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 +7590,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 +7602,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 +7618,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 +7665,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 +7677,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 +7703,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 +7727,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 +7735,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 +7747,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 +7755,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 +7773,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 +7806,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 +7976,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,