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

package/README.md

@@ -357,7 +357,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 | `"Edit"` | `Edit`, `MultiEdit` | `mcp__opencode_proxy__edit` |
 | `"Write"` | `Write` | `mcp__opencode_proxy__write` |
 | `"WebFetch"` | `WebFetch` | `mcp__opencode_proxy__webfetch` |
-| `"Task"` | `Agent` | `mcp__opencode_proxy__task` |
+| `"Task"` | `Agent` | `mcp__opencode_proxy__task`, `mcp__opencode_proxy__task_batch` |
 | `"Question"` | `AskUserQuestion` | `mcp__opencode_proxy__question` |
 | `"Compress"` | none | `mcp__opencode_proxy__compress` |
 
@@ -369,6 +369,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 - **Resume:** pass the child session ID back as `task_id` to continue that subagent session. Omit it to create a fresh child.
 - **Nested tasks:** current opencode defaults `subagent_depth` to `1`, so a first-level child cannot launch another child. Increase top-level `subagent_depth` to permit deeper nesting, and explicitly grant `permission.task` on every subagent that should delegate; opencode otherwise adds a task deny to spawned subagent sessions.
 - **Background:** `background: true` returns after starting the child and lets opencode notify the parent when it finishes. Current opencode requires `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` in the environment of the opencode process. Foreground is the default.
+- **Several at once:** `mcp__opencode_proxy__task_batch` takes a `tasks` array of ordinary task inputs and runs them concurrently. It exists because Claude Code sends MCP requests one at a time: when the model emits two `task` calls in one response, the second only leaves the CLI after the first has returned (measured live, 2026-09-06), so "launch two subagents" was always serial. The plugin turns one `task_batch` call into N opencode `task` calls inside a single tool boundary, which opencode executes in parallel, then hands the model every result together, labelled in task order. Same permissions, same 60-minute deadline, same `subagent_type` list. Enabled whenever `Task` is proxied. Designed and first implemented by [@broskees](https://github.com/broskees) on his fork.
 
 **Steering models to it.** Headless Claude Code CLIs expose no `Agent`/`Task`
 dispatch tool of their own (verified on 2.1.211), while they *do* expose
@@ -552,6 +553,20 @@ Notes:
 
 Fully restart opencode after upgrading to load the command and runtime changes. Other providers do not gain Claude's native side-question behavior from this command.
 
+## Configuration skill
+
+The package includes a `claude-code-plugin` skill so your agent can configure it without asking you to navigate all its options. Ask, for example:
+
+```text
+Use the claude-code-plugin skill to configure a work account and idle worker cleanup.
+```
+
+It covers accounts, models and agent effort, proxy tools, permissions, MCP/skill bridging, timeouts, logging, upgrades and troubleshooting. It directs the agent to preserve JSONC comments, change only requested settings, validate the result, protect credentials and ask before paid probes or broader permissions.
+
+The plugin registers the bundled directory with opencode's `skills.paths`, making it available to other providers too on supporting opencode versions. For ordinary headless Claude turns it also loads through Claude's native Skill tool as `opencode-skills:claude-code-plugin`, even when `bridgeOpencodeSkills` is off. This requires CLI `--plugin-dir` support; interactive transport, compaction and direct `doGenerate` calls do not load the native bridge.
+
+No separate skill installation or copying is needed. It ships with each package version, so upgrading updates the reference. Fully restart opencode to load it. `test-configure-skill.ts` checks coverage of provider/logging options, model ids, proxy tools and environment variables; maintainers must update behavior and default guidance in the same change as the implementation.
+
 ## Skill bridge
 
 opencode and Claude Code use the same on-disk skill format, a `<name>/SKILL.md` whose frontmatter carries `name` and `description`, but they read from different directories. opencode looks in `.opencode/skills/` and `~/.config/opencode/skills/`; the Claude CLI looks in `~/.claude/skills/` and its own plugins. So opencode advertises your skills in the system prompt it forwards, the model calls `Skill("browser-automation")`, and Claude answers `Unknown skill`.
@@ -567,7 +582,7 @@ Claude can invoke them with the Skill tool or as `/opencode-skills:<name>`. `--p
 
 Discovery order, first match wins: `.opencode/skills/` walking up from the working directory, then `~/.opencode/skills/`, then `$OPENCODE_CONFIG_DIR/skills/`, then `~/.config/opencode/skills/`. A project skill shadows a global one of the same name. If the skill set is unchanged the staged directory is reused between spawns.
 
-It is **off by default** here, unlike on the fork it came from: every bridged skill is also listed in the system prompt opencode already forwards, so a large skill set is paid for twice on every turn. Turn it on when you see `Unknown skill`. It no-ops on the compaction path and on a Claude CLI without `--plugin-dir` (the plugin probes `claude --help` and logs a notice).
+Bridging **your own skills is off by default** here, unlike on the fork it came from: every bridged skill is also listed in the system prompt opencode already forwards, so a large skill set is paid for twice on every turn. Turn it on when you see `Unknown skill`. The bundled configuration skill is loaded independently of this opt-in. The native bridge is not used for compaction or interactive transport, or on a Claude CLI without `--plugin-dir` (the plugin probes `claude --help` and logs a notice).
 
 This bridge was written by [@broskees](https://github.com/broskees) (Joseph Roberts) on his fork and absorbed here with credit; see [Credits](#credits).
 
@@ -965,7 +980,7 @@ This plugin absorbs work from its forks directly, cherry-picked with the origina
 | [@galvani](https://github.com/galvani) (Jan Kozak) | Per-session working directory for `opencode serve`, so one server spawns each project's `claude` in the right place. Also found the stale `toolCallMap` re-emission three months before it was fixed here. | `9e02ce4`, `2238ed0` |
 | [@HeikoAtGitHub](https://github.com/HeikoAtGitHub) | Stopped sending `AGENTS.md` to the model twice (opencode already forwards it). Independently diagnosed the 5-minute proxy wall. | `25260a4`, `42f426d` |
 | [@bernardofortes](https://github.com/bernardofortes) (Bernardo Fortes) | `idleProcessTimeoutMs`, idle eviction of retained `claude` workers. | `a5f723a` |
-| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, and the undici 300 s diagnosis of the proxy wall. | PR #18, `68ed142` |
+| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), and the undici 300 s diagnosis of the proxy wall. | PR #18, `68ed142` |
 | [@jknlsn](https://github.com/jknlsn) (Jake Nelson) | Per-tool proxy timeouts, subagent dispatch steering, the question proxy, the start watchdog respawn. | `84f3db9`, `94980a6`, `47501d0`, `ffefc24` |
 | [@CollieIsCute](https://github.com/CollieIsCute) (Collie Tsai) | The plan-mode approval bridge. | `8c5b583` |
 | [@flupkede](https://github.com/flupkede) | The compress proxy tool design and the AI-SDK v4 image-part fix. | `4ac319f`, `60a6e9a` |

package/dist/index.d.ts

@@ -78,6 +78,10 @@ type OpenCodeConfig = {
         models?: Record<string, unknown>;
     }>;
     agent?: Record<string, Record<string, unknown>>;
+    skills?: {
+        paths?: string[];
+        urls?: string[];
+    };
 };
 /**
  * Bus events surface to plugins. Shape mirrors what opencode core publishes
@@ -630,6 +634,16 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      */
     private ensureProxyServer;
     private extractPendingProxyResult;
+    /**
+     * 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.
+     */
+    private extractPendingProxyResultForCall;
     /**
      * Resolve the session affinity token for this LLM call. Delegates to the
      * exported `resolveSessionAffinity` helper so the logic is unit-testable.

package/dist/index.js

@@ -447,10 +447,13 @@ function detectCliSupportsFlag(cliPath, flag) {
   if (cached) return cached;
   const promise = (async () => {
     try {
-      const { stdout } = await execFileAsync(cliPath, ["--help"], {
+      const execution = execFileAsync(cliPath, ["--help"], {
         timeout: 5e3,
+        killSignal: "SIGKILL",
         maxBuffer: 4 * 1024 * 1024
       });
+      execution.child.stdin?.end();
+      const { stdout } = await execution;
       return stdout.includes(flag);
     } catch (err) {
       log.warn("failed to probe claude cli flag support", {
@@ -523,6 +526,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
 };
@@ -562,14 +567,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.";
@@ -597,7 +646,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
   );
@@ -615,6 +664,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",
@@ -708,35 +783,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"]
     }
   },
   {
@@ -922,6 +992,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;
@@ -1126,6 +1203,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
@@ -3227,7 +3305,17 @@ import * as crypto2 from "crypto";
 import * as fs3 from "fs";
 import * as os2 from "os";
 import * as path4 from "path";
+import { fileURLToPath } from "url";
 var SKILL_PLUGIN_NAME = "opencode-skills";
+function bundledSkillsDir() {
+  try {
+    const here = fileURLToPath(import.meta.url);
+    const dir = path4.resolve(path4.dirname(here), "..", "skills");
+    return dirExists(dir) ? dir : null;
+  } catch {
+    return null;
+  }
+}
 function dirExists(p) {
   try {
     return fs3.statSync(p).isDirectory();
@@ -3266,28 +3354,46 @@ function skillRoots(cwd) {
   if (xdg) push(path4.join(xdg, "opencode", "skills"));
   return roots;
 }
+function collectSkills(root, claimed, found) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  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 });
+  }
+}
+var byName = (a, b) => a.name.localeCompare(b.name);
 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));
+  for (const root of skillRoots(cwd)) collectSkills(root, claimed, found);
+  return found.sort(byName);
+}
+function discoverBundledSkills() {
+  const root = bundledSkillsDir();
+  if (!root) return [];
+  const found = [];
+  collectSkills(root, /* @__PURE__ */ new Set(), found);
+  return found.sort(byName);
+}
+function registerBundledSkillPath(config) {
+  const dir = bundledSkillsDir();
+  if (!dir) return false;
+  config.skills ??= {};
+  const paths = config.skills.paths ??= [];
+  if (paths.some((p) => path4.resolve(p) === dir)) return false;
+  paths.push(dir);
+  return true;
 }
 function linkSkill(source, target) {
   try {
@@ -3333,8 +3439,10 @@ function buildSkillPluginDir(skills) {
   return root;
 }
 async function resolveSkillPluginDirs(opts) {
-  if (!opts.enabled) return [];
-  const skills = discoverOpencodeSkills(opts.cwd);
+  const user = opts.enabled ? discoverOpencodeSkills(opts.cwd) : [];
+  const claimed = new Set(user.map((s) => s.name));
+  const bundled = discoverBundledSkills().filter((s) => !claimed.has(s.name));
+  const skills = [...user, ...bundled].sort(byName);
   if (skills.length === 0) return [];
   const supported = await detectCliSupportsFlag(opts.cliPath, "--plugin-dir");
   if (!supported) {
@@ -3349,6 +3457,7 @@ async function resolveSkillPluginDirs(opts) {
   log.info("bridged opencode skills into claude", {
     count: skills.length,
     names: skills.map((s) => s.name),
+    bundled: bundled.map((s) => s.name),
     pluginDir: dir
   });
   return [dir];
@@ -4599,8 +4708,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.
@@ -4804,11 +4914,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(", ");
@@ -4998,6 +5121,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.
@@ -5809,7 +5967,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
@@ -6271,20 +6429,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({
@@ -7532,7 +7704,7 @@ import {
 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join8, resolve as resolve4 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
 var alreadyRan = false;
@@ -7564,7 +7736,7 @@ function userIntendsToUseUnscoped() {
 }
 function ourLoadedDir() {
   try {
-    const filePath = fileURLToPath(import.meta.url);
+    const filePath = fileURLToPath2(import.meta.url);
     return realpathSync(resolve4(filePath, "..", ".."));
   } catch {
     return null;
@@ -7638,12 +7810,12 @@ import { execFile as execFile2 } from "child_process";
 import * as fs6 from "fs";
 import * as path8 from "path";
 import { promisify as promisify2 } from "util";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path8.dirname(fileURLToPath2(import.meta.url));
+    const here = path8.dirname(fileURLToPath3(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";
@@ -8039,6 +8211,7 @@ var server = async (input) => {
   return {
     config: async (config) => {
       if (registerSideQuestionCommand(config)) ownsSideQuestionCommand = true;
+      registerBundledSkillPath(config);
       config.provider ??= {};
       await buildAgentRegistry(config);
       const expanded = await expandAccountProviders(config);