@khalilgharbaoui/opencode-claude-code-plugin 0.32.0 → 0.33.1

package/dist/index.js

@@ -1633,12 +1633,12 @@ function setProxyDeadlineGuard(guard) {
 var PROXY_DEADLINE_RECHECK_MS = 6e4;
 var deadlineRecheckMs = PROXY_DEADLINE_RECHECK_MS;
 function armProxyDeadline(opts) {
-  let cancelled = false;
+  let cancelled2 = false;
   let extended = false;
   let timer = null;
   const check = async () => {
     timer = null;
-    if (cancelled) return;
+    if (cancelled2) return;
     let keep = false;
     const guard = proxyDeadlineGuard;
     if (guard) {
@@ -1648,7 +1648,7 @@ function armProxyDeadline(opts) {
         keep = false;
       }
     }
-    if (cancelled) return;
+    if (cancelled2) return;
     if (keep) {
       if (!extended && opts.logExtension) {
         log.warn("proxy call past its deadline, but opencode is still serving it; waiting", {
@@ -1667,7 +1667,7 @@ function armProxyDeadline(opts) {
   timer = setTimeout(() => void check(), opts.deadlineMs);
   return {
     cancel() {
-      cancelled = true;
+      cancelled2 = true;
       if (timer) clearTimeout(timer);
       timer = null;
     }
@@ -1685,6 +1685,7 @@ function buildProxyTimeoutError(toolName, ms) {
 }
 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. Calls block until the subagent finishes. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls have no proxy deadline by default: the call waits for the subagent to finish (a positive proxyToolTimeoutMs override adds a deadline).";
 var TASK_BACKGROUND_NOTE = 'Fire-and-collect: set `background: true` and the call returns at once with `<task id="ses_..." state="running">` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own as a new message. Do NOT poll, sleep or loop waiting for it. The `id` in that envelope is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want.';
+var TASK_BACKGROUND_NOTE_V2 = 'Fire-and-collect: set `background: true` and the call returns at once with `The subagent is working in the background (sessionID: ses_...)` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own, as a `<subagent sessionID="..." state="completed">` message. Do NOT poll, sleep or loop waiting for it. That sessionID is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want.';
 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. Like task it has no proxy deadline by default (a positive proxyToolTimeoutMs override adds one).";
 var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
@@ -1785,7 +1786,7 @@ var BACKGROUND_TASK_TOOL_DEFS = [
       properties: {
         task_id: {
           type: "string",
-          description: 'The id from the `<task id="..." state="running">` envelope the background dispatch returned.'
+          description: 'The background subagent\'s own opencode session id: the `id` in the `<task id="..." state="running">` envelope on opencode 1.x, or the `sessionID` the background dispatch reported on opencode 2.'
         }
       },
       required: ["task_id"]
@@ -1799,21 +1800,22 @@ var BACKGROUND_TASK_TOOL_DEFS = [
       properties: {
         task_id: {
           type: "string",
-          description: 'The id from the `<task id="..." state="running">` envelope the background dispatch returned.'
+          description: 'The background subagent\'s own opencode session id: the `id` in the `<task id="..." state="running">` envelope on opencode 1.x, or the `sessionID` the background dispatch reported on opencode 2.'
         }
       },
       required: ["task_id"]
     }
   }
 ];
-function applyBackgroundSubagentSupport(tools, supported) {
+function applyBackgroundSubagentSupport(tools, supported, dialect = "v1") {
   if (!tools.some((t) => t.name === "task")) return tools;
+  const note = dialect === "v2" ? TASK_BACKGROUND_NOTE_V2 : TASK_BACKGROUND_NOTE;
   const adjusted = tools.map((t) => {
     if (t.name !== "task" && t.name !== TASK_BATCH_TOOL_NAME) return t;
     if (supported) {
       return { ...t, description: `${t.description}
 
-${TASK_BACKGROUND_NOTE}` };
+${note}` };
     }
     return { ...t, inputSchema: stripBackgroundFromSchema(t.name, t.inputSchema) };
   });
@@ -2432,7 +2434,9 @@ function resolveDisallowedTools(options) {
 function resolveProxyOpencodeToolDefs(options) {
   const requested = options.requested ?? [];
   if (requested.length === 0) return [];
-  const items = options.items;
+  const items = options.modelTools !== void 0 ? options.modelTools.flatMap(
+    (tool) => (tool.type === void 0 || tool.type === "function") && typeof tool.name === "string" ? [{ id: tool.name, description: tool.description, parameters: tool.inputSchema }] : []
+  ) : options.items;
   if (!items) {
     log.warn(
       "proxyOpencodeTools is set but opencode's tool registry did not answer; forwarding nothing this spawn",
@@ -2458,12 +2462,20 @@ function resolveProxyOpencodeToolDefs(options) {
       unknown.push(name);
       continue;
     }
+    if (item.id === "execute" && options.allowCodeExecution === false) {
+      log.warn("Code Mode execute not forwarded: read-only permission preset");
+      continue;
+    }
     if (taken.has(item.id)) {
       collided.push(item.id);
       continue;
     }
     if (seen.has(item.id)) continue;
     seen.add(item.id);
+    if (item.id === "execute" && (!item.parameters || typeof item.parameters !== "object" || Array.isArray(item.parameters) || !Object.keys(item.parameters).length)) {
+      log.warn("Code Mode execute not forwarded: no model-visible input schema");
+      continue;
+    }
     out.push({
       name: item.id,
       description: typeof item.description === "string" ? item.description : "",
@@ -2500,6 +2512,7 @@ function resolveMcpProxyToolDefs(options) {
     if (tool?.type !== void 0 && tool.type !== "function") continue;
     const name = typeof tool?.name === "string" ? tool.name.trim() : "";
     if (!name) continue;
+    if (name === "execute") continue;
     const matchedServer = serversByLengthDesc.find(
       (server2) => name === server2 || name.startsWith(`${server2}_`)
     );
@@ -3132,8 +3145,8 @@ async function abortSession(sessionID) {
   const client = opencodeClient;
   if (!client?.session?.abort) return false;
   try {
-    await client.session.abort({ path: { id: sessionID } });
-    return true;
+    const res = await client.session.abort({ path: { id: sessionID } });
+    return res.data !== false;
   } catch (err) {
     log.warn("failed to abort opencode session", {
       sessionID,
@@ -3149,21 +3162,22 @@ var TASK_CANCEL_TOOL_NAME = "task_cancel";
 var MAX_LEDGERS = 32;
 var MAX_COLLECTED_PER_SESSION = 64;
 var collected = /* @__PURE__ */ new Map();
-function ledgerFor(sessionKey2) {
-  let ids = collected.get(sessionKey2);
+var cancelled = /* @__PURE__ */ new Map();
+function ledgerIn(ledgers2, sessionKey2) {
+  let ids = ledgers2.get(sessionKey2);
   if (!ids) {
     ids = /* @__PURE__ */ new Set();
-    collected.set(sessionKey2, ids);
-    while (collected.size > MAX_LEDGERS) {
-      const oldest = collected.keys().next();
+    ledgers2.set(sessionKey2, ids);
+    while (ledgers2.size > MAX_LEDGERS) {
+      const oldest = ledgers2.keys().next();
       if (oldest.done) break;
-      collected.delete(oldest.value);
+      ledgers2.delete(oldest.value);
     }
   }
   return ids;
 }
-function markCollected(sessionKey2, taskId) {
-  const ids = ledgerFor(sessionKey2);
+function mark(ledgers2, sessionKey2, taskId) {
+  const ids = ledgerIn(ledgers2, sessionKey2);
   ids.add(taskId);
   while (ids.size > MAX_COLLECTED_PER_SESSION) {
     const oldest = ids.values().next();
@@ -3171,11 +3185,30 @@ function markCollected(sessionKey2, taskId) {
     ids.delete(oldest.value);
   }
 }
+function markCollected(sessionKey2, taskId) {
+  mark(collected, sessionKey2, taskId);
+}
 function hasCollectedBackgroundTask(sessionKey2, taskId) {
   return collected.get(sessionKey2)?.has(taskId) === true;
 }
 function clearBackgroundTasks(sessionKey2) {
   collected.delete(sessionKey2);
+  cancelled.delete(sessionKey2);
+}
+var lastGate;
+function recordBackgroundSubagentGate(gate, now = Date.now()) {
+  lastGate = { ...gate, at: now };
+}
+function snapshotBackgroundSubagentGate() {
+  return lastGate ? { ...lastGate } : void 0;
+}
+function snapshotBackgroundTasks() {
+  const keys = /* @__PURE__ */ new Set([...collected.keys(), ...cancelled.keys()]);
+  return [...keys].map((sessionKey2) => ({
+    sessionKey: sessionKey2,
+    collected: [...collected.get(sessionKey2) ?? []],
+    cancelled: [...cancelled.get(sessionKey2) ?? []]
+  }));
 }
 function readTaskId(input) {
   const raw = input.task_id ?? input.taskId ?? input.sessionID;
@@ -3183,14 +3216,20 @@ function readTaskId(input) {
   const id = raw.trim();
   return id.length > 0 ? id : null;
 }
-var MISSING_TASK_ID = 'task_id is required: pass the id from the `<task id="...">` envelope the background dispatch returned.';
+var MISSING_TASK_ID = 'task_id is required: pass the background subagent\'s own opencode session id, from the `<task id="...">` envelope on opencode 1.x or the `sessionID` the background dispatch reported on opencode 2.';
 async function guardParent(taskId, callerSessionId) {
   if (!callerSessionId || callerSessionId === "default") {
     return `Cannot check that task_id ${taskId} belongs to this conversation (this turn has no opencode session id), so it is not inspected or cancelled.`;
   }
   const parent = await fetchSessionParentId(taskId);
   if (parent === callerSessionId) return null;
-  return `task_id ${taskId} is not a subagent of this conversation, so it cannot be inspected or cancelled from here. Use the id from a \`<task id="...">\` envelope this conversation received.`;
+  return `task_id ${taskId} is not a subagent of this conversation, so it cannot be inspected or cancelled from here. Use the session id from a background dispatch this conversation itself made.`;
+}
+function isBackgroundTaskRunning(runState, replies) {
+  if (runState === "busy") return true;
+  if (runState === "idle") return false;
+  const reply = lastAssistantReply(replies);
+  return reply !== void 0 && !reply.completed && reply.error === void 0;
 }
 function lastAssistantReply(replies) {
   for (let index = replies.length - 1; index >= 0; index--) {
@@ -3212,7 +3251,7 @@ async function collectBackgroundTask(input, options) {
     };
   }
   const runState = await fetchSessionRunState(taskId);
-  if (runState === "busy") {
+  if (isBackgroundTaskRunning(runState, replies)) {
     return {
       kind: "text",
       text: `<task id="${taskId}" state="running">
@@ -3267,7 +3306,10 @@ async function cancelBackgroundTask(input, options) {
   if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
   const refused = await guardParent(taskId, options.callerSessionId);
   if (refused) return { kind: "error", message: refused };
-  const before = await fetchSessionRunState(taskId);
+  const running = isBackgroundTaskRunning(
+    await fetchSessionRunState(taskId),
+    await fetchSessionReplies(taskId) ?? []
+  );
   const aborted = await abortSession(taskId);
   if (!aborted) {
     return {
@@ -3276,15 +3318,16 @@ async function cancelBackgroundTask(input, options) {
     };
   }
   collected.get(options.sessionKey)?.delete(taskId);
+  mark(cancelled, options.sessionKey, taskId);
   log.info("cancelled background subagent", {
     sessionKey: options.sessionKey,
     taskId,
-    wasRunning: before === "busy"
+    wasRunning: running
   });
   return {
     kind: "text",
     text: `<task id="${taskId}" state="cancelled">
-` + (before === "busy" ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
+` + (running ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
   };
 }
 
@@ -4677,24 +4720,24 @@ function globalConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME ?? path4.join(os2.homedir(), ".config");
   return path4.join(xdg, "opencode");
 }
-function loadGlobalConfig() {
+function loadGlobalConfig(hostApi = "v1") {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
     const file = path4.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
-    if (parsed) merged = deepMerge(merged, parsed);
+    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
   }
   return merged;
 }
-function loadProjectFilesInDir(dir) {
+function loadProjectFilesInDir(dir, hostApi = "v1") {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
     const file = path4.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
-    if (parsed) merged = deepMerge(merged, parsed);
+    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
   }
   return merged;
 }
@@ -4781,8 +4824,29 @@ function translateServer(name, spec) {
 }
 function extractMcpBlock(config) {
   const mcp = config.mcp;
-  if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) return {};
-  return mcp;
+  if (!isPlainObject(mcp)) return {};
+  if ("servers" in mcp && !isPlainObject(mcp.servers)) return {};
+  const native = isPlainObject(mcp.servers) && typeof mcp.servers.type !== "string" && typeof mcp.servers.enabled !== "boolean" && typeof mcp.servers.disabled !== "boolean";
+  const block = native ? mcp.servers : mcp;
+  return Object.fromEntries(
+    Object.entries(block).filter(([name, spec]) => isPlainObject(spec) && (native || name !== "timeout" || typeof spec.type === "string")).map(([name, spec]) => {
+      const server2 = spec;
+      return [name, {
+        ...server2,
+        ...typeof server2.disabled === "boolean" ? { enabled: !server2.disabled } : {}
+      }];
+    })
+  );
+}
+function mergeConfigLayer(target, source, hostApi) {
+  const merged = deepMerge(target, source);
+  if (hostApi === "v2" && isPlainObject(source.mcp)) {
+    merged.mcp = {
+      ...isPlainObject(merged.mcp) ? merged.mcp : {},
+      servers: { ...extractMcpBlock(target), ...extractMcpBlock(source) }
+    };
+  }
+  return merged;
 }
 function mergeMcp(target, source) {
   const out = { ...target };
@@ -4800,12 +4864,12 @@ function mergeMcp(target, source) {
   }
   return out;
 }
-function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
+function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers, hostApi = "v1") {
   const {
     servers: merged,
     enabledServerNames: allEnabledServerNames,
     hash
-  } = mergeOpencodeMcp(cwd, runtimeStatus);
+  } = mergeOpencodeMcp(cwd, runtimeStatus, hostApi);
   const servers = {};
   const bridgedServerNames = [];
   for (const [name, spec] of Object.entries(merged)) {
@@ -4825,10 +4889,10 @@ function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
     excludeServers
   });
 }
-function opencodeConfigLayers(cwd) {
-  const worktree = detectWorktree(cwd);
+function opencodeConfigLayers(cwd, hostApi = "v1") {
+  const worktree = hostApi === "v2" ? void 0 : detectWorktree(cwd);
   const layers = [];
-  layers.push(loadGlobalConfig());
+  layers.push(loadGlobalConfig(hostApi));
   const explicitConfig = process.env.OPENCODE_CONFIG;
   if (explicitConfig && fileExists(explicitConfig)) {
     const parsed = readAndParse(explicitConfig);
@@ -4850,22 +4914,30 @@ function opencodeConfigLayers(cwd) {
     }
   }
   for (const dir of projectDirs.slice().reverse()) {
-    layers.push(loadProjectFilesInDir(dir));
+    layers.push(loadProjectFilesInDir(dir, hostApi));
   }
-  for (const dir of dotOpencodeDirs(cwd, worktree)) {
-    layers.push(loadProjectFilesInDir(dir));
+  if (hostApi === "v2") {
+    const dirs = walkUp({ start: cwd, targets: [".opencode"], predicate: dirExists }).reverse();
+    const extra = process.env.OPENCODE_CONFIG_DIR;
+    if (extra && dirExists(extra)) layers.push(loadProjectFilesInDir(extra, hostApi));
+    for (const dir of dirs) layers.push(loadProjectFilesInDir(dir, hostApi));
+  } else {
+    for (const dir of dotOpencodeDirs(cwd, worktree)) {
+      layers.push(loadProjectFilesInDir(dir));
+    }
   }
   return layers;
 }
-function loadMergedOpencodeConfig(cwd) {
+function loadMergedOpencodeConfig(cwd, hostApi = "v1") {
   let merged = {};
-  for (const layer of opencodeConfigLayers(cwd)) merged = deepMerge(merged, layer);
+  for (const layer of opencodeConfigLayers(cwd, hostApi)) merged = mergeConfigLayer(merged, layer, hostApi);
   return merged;
 }
-function mergeOpencodeMcp(cwd, runtimeStatus) {
+function mergeOpencodeMcp(cwd, runtimeStatus, hostApi = "v1") {
   let merged = {};
-  for (const layer of opencodeConfigLayers(cwd)) {
-    merged = mergeMcp(merged, extractMcpBlock(layer));
+  for (const layer of opencodeConfigLayers(cwd, hostApi)) {
+    const servers = extractMcpBlock(layer);
+    merged = hostApi === "v2" ? { ...merged, ...servers } : mergeMcp(merged, servers);
   }
   if (runtimeStatus) {
     for (const name of Object.keys(merged)) {
@@ -5005,7 +5077,8 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
   const cwd = describeSpawnCwd(firstOption(providers, "cwd"));
   let mcpServers = [];
   try {
-    mcpServers = mergeOpencodeMcp(cwd.resolved).enabledServerNames;
+    const hostApi = firstOption(providers, "hostApi") === "v2" || opencodeVersion?.replace(/^v/, "").startsWith("2.") ? "v2" : "v1";
+    mcpServers = mergeOpencodeMcp(cwd.resolved, void 0, hostApi).enabledServerNames;
   } catch (err) {
     log.debug("startup diagnostics could not read MCP config", {
       error: err instanceof Error ? err.message : String(err)
@@ -5219,6 +5292,10 @@ function formatDoctorReport(report) {
     }
   }
   lines.push("");
+  lines.push("**Background subagents**");
+  lines.push("");
+  lines.push(...formatBackgroundSubagents(report.backgroundSubagents));
+  lines.push("");
   lines.push("**Plan usage**");
   lines.push("");
   switch (report.planUsage.status) {
@@ -5251,6 +5328,59 @@ function formatDoctorReport(report) {
   }
   return lines.join("\n");
 }
+function formatBackgroundSubagents(state) {
+  const lines = [];
+  const gate = state.gate;
+  if (!gate) {
+    lines.push(
+      "Not read yet this process. The gate is resolved the first time a turn plans its proxy tools, so send one message and run this again."
+    );
+  } else {
+    lines.push("| Field | Value |");
+    lines.push("|---|---|");
+    lines.push(`| \`background\` offered to Claude | ${gate.supported ? "yes" : "no"} |`);
+    lines.push(
+      `| \`task_status\` / \`task_cancel\` | ${gate.supported ? "registered" : "not registered"} |`
+    );
+    lines.push(`| opencode API | ${gate.hostApi} |`);
+    lines.push(`| decided from | ${describeBackgroundGateSource(gate)} |`);
+    lines.push(`| read | ${formatAge(Math.max(0, Date.now() - gate.at))} ago |`);
+    if (!gate.supported && gate.hostApi === "v1") {
+      lines.push("");
+      lines.push(
+        "opencode 1.x keeps background subagents behind a flag on its OWN process: set `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true` (or the blanket `OPENCODE_EXPERIMENTAL`) in opencode's environment and restart it. The plugin never reads that variable itself; it reads whether opencode's advertised `task` schema carries a `background` property, which is how opencode publishes the flag."
+      );
+    }
+  }
+  const active = state.ledgers.filter(
+    (ledger) => ledger.collected.length > 0 || ledger.cancelled.length > 0
+  );
+  lines.push("");
+  if (active.length === 0) {
+    lines.push("No background task has been collected or cancelled by this process.");
+  } else {
+    lines.push("| session | collected | cancelled |");
+    lines.push("|---|---|---|");
+    for (const ledger of active) {
+      lines.push(
+        `| ${describeSessionKey(ledger.sessionKey).session} | ${list(ledger.collected)} | ${list(
+          ledger.cancelled
+        )} |`
+      );
+    }
+    lines.push("");
+    lines.push(
+      "A collected task is one this conversation read back with `task_status`, or was told about by opencode's own completion notification; a result is handed over once."
+    );
+  }
+  return lines;
+}
+function describeBackgroundGateSource(gate) {
+  if (gate.hostApi === "v2") {
+    return "opencode 2 offers `background` unconditionally, so the registry is not consulted";
+  }
+  return gate.registryResolved ? "opencode's live `task` schema" : "opencode's live tool registry did not answer, so the answer defaulted to no";
+}
 async function checkProxyAuth(url, fetchImpl = fetch, timeoutMs = 3e3) {
   let authority;
   try {
@@ -5317,7 +5447,11 @@ async function gatherDoctorReport(options) {
     proxyServers,
     mcpServerErrors: snapshotMcpServerErrors(),
     pluginLoadFailures: snapshotPluginLoadFailures(),
-    planUsage
+    planUsage,
+    backgroundSubagents: {
+      gate: snapshotBackgroundSubagentGate(),
+      ledgers: snapshotBackgroundTasks()
+    }
   };
 }
 async function buildDoctorReport(options) {
@@ -5332,7 +5466,8 @@ async function buildDoctorReport(options) {
       proxyServers: report.proxyServers.map((server2) => server2.auth.status),
       mcpServerErrors: report.mcpServerErrors.length,
       pluginLoadFailures: report.pluginLoadFailures.length,
-      planUsage: report.planUsage.status
+      planUsage: report.planUsage.status,
+      backgroundSubagents: report.backgroundSubagents.gate?.supported ?? "not read"
     });
     return formatDoctorReport(report);
   } catch (error) {
@@ -6820,7 +6955,13 @@ function resolveClaude(cmd = "claude") {
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  return path8.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+  const resolved = path8.resolve(cwd);
+  let real = resolved;
+  try {
+    real = fs6.realpathSync.native(resolved);
+  } catch {
+  }
+  return real.replace(/[^a-zA-Z0-9]/g, "-");
 }
 function interactiveSpawnEnv(opts) {
   return {
@@ -7341,16 +7482,18 @@ function spawnInteractiveProcess(opts) {
     if (!startPromise) startPromise = session.start();
     return startPromise;
   };
-  const emitResult = (subtype, isError, result, usage) => {
+  const emitResult = (opts2) => {
     lineEmitter.emit(
       "line",
       JSON.stringify({
         type: "result",
-        subtype,
-        is_error: isError,
-        result,
+        subtype: opts2.subtype,
+        is_error: opts2.isError,
+        stop_reason: opts2.stopReason,
+        terminal_reason: opts2.terminalReason,
+        result: opts2.result,
         session_id: session.sessionId,
-        usage: usage ?? {},
+        usage: opts2.usage ?? {},
         total_cost_usd: null,
         duration_ms: 0
       })
@@ -7373,20 +7516,24 @@ function spawnInteractiveProcess(opts) {
           lastCallCacheWriteTokens: lastCallUsage?.cache_creation_input_tokens
         });
         const timedOut = !stopReason;
-        emitResult(
-          timedOut ? "error_during_execution" : stopReason,
-          timedOut,
-          timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
+        emitResult({
+          subtype: timedOut ? "error_during_execution" : "success",
+          isError: timedOut,
+          stopReason: timedOut ? null : stopReason,
+          terminalReason: timedOut ? "error_during_execution" : "completed",
+          result: timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
           usage
-        );
+        });
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
         log.error("interactive turn failed", { error: e.message });
-        emitResult(
-          "error_during_execution",
-          true,
-          `Interactive transport failed: ${e.message}`
-        );
+        emitResult({
+          subtype: "error_during_execution",
+          isError: true,
+          stopReason: null,
+          terminalReason: "error_during_execution",
+          result: `Interactive transport failed: ${e.message}`
+        });
         if (errorHandlers.size > 0) {
           for (const h of errorHandlers) h(e);
         } else {
@@ -7503,6 +7650,13 @@ Structured questions in this environment go through exactly one tool: \`mcp__ope
 - If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__question\`), then call it by its FULL name.
 - Do NOT call bare \`question\` \u2014 that is not a tool. Always use the full \`mcp__opencode_proxy__question\` name when invoking it.
 - Claude Code's built-in \`AskUserQuestion\` is disabled in this environment; the proxy is the only way to ask structured questions.`;
+function codeModeProxyHint(active) {
+  return active ? `## opencode Code Mode
+
+Instructions referring to the execute tool mean \`mcp__opencode_proxy__execute\` in this Claude Code session. Use its full name; if deferred, load it with ToolSearch (\`select:mcp__opencode_proxy__execute\`). Pass the code argument unchanged, using the provided catalog's exact \`search(...)\` and \`tools[...]\` signatures inside that code. The catalog tools are not separate Claude tools. Calls execute in opencode under this session's permissions.` : `## opencode Code Mode unavailable
+
+The forwarded opencode catalog may mention execute, but this session does not expose an execute proxy. Do not invent an execute tool or claim a catalog call ran. For MCP servers available directly in Claude Code, discover their actual MCP tools with ToolSearch instead. If no matching tool exists, report that limitation; a shell/CLI call is not a test of MCP.`;
+}
 var CLAUDE_CLI_CONTEXT_NOTE = `## Runtime environment: Claude Code CLI
 
 You are running via the Claude Code CLI (not a direct API call). This affects context management:
@@ -7988,7 +8142,7 @@ function effectiveMcpConfig(config, cwd, proxyConfigPath, runtimeStatus, exclude
   let bridgedHash = null;
   let allEnabledServerNames = [];
   if (config.bridgeOpencodeMcp !== false) {
-    const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers);
+    const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers, config.hostApi);
     if (bridged) {
       if (bridged.path) paths.push(bridged.path);
       bridgedHash = bridged.hash;
@@ -8048,7 +8202,7 @@ function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken)
   });
   if (resolution.defs.length === 0) {
     log.warn(
-      "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn",
+      "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn" + (config.hostApi === "v2" && modelTools?.some((tool) => tool.name === "execute") ? ". For V2 Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true" : ""),
       { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
     );
     return null;
@@ -10547,18 +10701,25 @@ var ClaudeCodeLanguageModel = class {
                     )
                   )
                 });
+                const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
                 backgroundSubagentsSupported = liveTaskSupportsBackground(
                   liveToolInfo.taskParameters,
-                  self.config.hostApi === "v2" ? "v2" : "v1"
+                  hostDialect
                 );
                 enrichedProxy = applyBackgroundSubagentSupport(
                   enrichedProxy,
-                  backgroundSubagentsSupported
+                  backgroundSubagentsSupported,
+                  hostDialect
                 );
+                recordBackgroundSubagentGate({
+                  supported: backgroundSubagentsSupported,
+                  hostApi: hostDialect,
+                  registryResolved: liveToolInfo.resolved
+                });
                 log.info("background subagent gate", {
                   supported: backgroundSubagentsSupported,
                   registryResolved: liveToolInfo.resolved,
-                  hostApi: self.config.hostApi ?? "v1",
+                  hostApi: hostDialect,
                   note: backgroundSubagentsSupported ? "task accepts `background`; task_status and task_cancel are registered" : "`background` stripped from the task schema; set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true in opencode's environment to enable it"
                 });
               }
@@ -10579,6 +10740,8 @@ var ClaudeCodeLanguageModel = class {
               const opencodeToolDefs = resolveProxyOpencodeToolDefs({
                 requested: self.config.proxyOpencodeTools,
                 items: liveToolInfo.items,
+                modelTools: self.config.hostApi === "v2" ? options.tools ?? [] : void 0,
+                allowCodeExecution: self.config.permissionPreset !== "read-only",
                 taken: new Set(
                   [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
                     (t) => t.name
@@ -10624,7 +10787,8 @@ var ClaudeCodeLanguageModel = class {
                   ...extractSystemMessages(options.prompt),
                   ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
                   ...backgroundSubagentsSupported ? [BACKGROUND_SUBAGENT_HINT] : [],
-                  ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
+                  ...questionProxyActive ? [QUESTION_PROXY_HINT] : [],
+                  ...self.config.hostApi === "v2" && options.tools?.some((t) => t.name === "execute") ? [codeModeProxyHint(opencodeToolDefs.some((t) => t.name === "execute"))] : []
                 ],
                 {
                   compressEnabled: pluginCompressEnabled,
@@ -11203,7 +11367,7 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync6,
-  realpathSync as realpathSync2,
+  realpathSync as realpathSync3,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
@@ -11242,7 +11406,7 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath3(import.meta.url);
-    return realpathSync2(resolve5(filePath, "..", ".."));
+    return realpathSync3(resolve5(filePath, "..", ".."));
   } catch {
     return null;
   }
@@ -11311,7 +11475,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
-    realStalePath = realpathSync2(stalePath);
+    realStalePath = realpathSync3(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
@@ -11384,6 +11548,30 @@ function toV1Session(info) {
   const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path9.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
+function toV1Messages(messages) {
+  if (!Array.isArray(messages)) return [];
+  return messages.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const message = entry;
+    const parts = Array.isArray(message.content) ? message.content.flatMap((part) => {
+      if (!part || typeof part !== "object") return [];
+      const piece = part;
+      return piece.type === "text" && typeof piece.text === "string" ? [{ type: "text", text: piece.text }] : [];
+    }) : typeof message.text === "string" ? [{ type: "text", text: message.text }] : [];
+    const error = message.error;
+    const info = {
+      role: typeof message.type === "string" ? message.type : "",
+      time: message.time && typeof message.time === "object" ? message.time : {},
+      ...error && typeof error === "object" ? {
+        error: {
+          name: typeof error.type === "string" ? error.type : "error",
+          data: { message: typeof error.message === "string" ? error.message : void 0 }
+        }
+      } : {}
+    };
+    return [{ info, parts }];
+  });
+}
 function createV1ClientShim(ctx) {
   const client = {};
   const mcpList = ctx.mcp?.list;
@@ -11408,7 +11596,8 @@ function createV1ClientShim(ctx) {
     client.tool = {
       // V1: `{ data: [{ id, description, parameters }] }`. V2 returns the tools
       // themselves, with an Effect schema for input rather than JSON Schema, so
-      // `parameters` is empty; only `proxyOpencodeTools` reads it.
+      // `parameters` is empty. V2 proxyOpencodeTools uses the per-turn model
+      // snapshot instead, which also includes synthesized Code Mode execute.
       list: async () => {
         const tools = await toolList.call(ctx.tool);
         const data = (tools ?? []).flatMap((tool) => {
@@ -11436,13 +11625,27 @@ ${agentList}` : subagent.description;
     };
   }
   const sessionGet = ctx.session?.get;
+  const sessionContext = ctx.session?.context;
+  const sessionInterrupt = ctx.session?.interrupt;
+  const session = {};
   if (typeof sessionGet === "function") {
-    client.session = {
-      get: async (options) => ({
-        data: toV1Session(await sessionGet.call(ctx.session, { sessionID: options.path.id }))
-      })
+    session.get = async (options) => ({
+      data: toV1Session(await sessionGet.call(ctx.session, { sessionID: options.path.id }))
+    });
+  }
+  if (typeof sessionContext === "function") {
+    session.messages = async (options) => ({
+      data: toV1Messages(await sessionContext.call(ctx.session, { sessionID: options.path.id }))
+    });
+  }
+  if (typeof sessionInterrupt === "function") {
+    session.abort = async (options) => {
+      const result = await sessionInterrupt.call(ctx.session, { sessionID: options.path.id });
+      const interrupted = result?.interrupted;
+      return { data: typeof interrupted === "boolean" ? interrupted : true };
     };
   }
+  if (Object.keys(session).length > 0) client.session = session;
   return client;
 }
 
@@ -11575,9 +11778,11 @@ function plainObject(value) {
 }
 function configuredSeedSettings(config, pluginOptions) {
   const provider = plainObject(plainObject(config.provider)?.[BASE_PROVIDER_ID]);
+  const nativeProvider = plainObject(plainObject(config.providers)?.[BASE_PROVIDER_ID]);
   return {
     ...plainObject(provider?.options) ?? {},
     ...plainObject(provider?.settings) ?? {},
+    ...plainObject(nativeProvider?.settings) ?? {},
     ...pluginOptions ?? {}
   };
 }
@@ -12225,7 +12430,7 @@ var index_default = {
   setup: createV2Setup({
     createProvider: createClaudeCode,
     defaultProxyTools: DEFAULT_PROXY_TOOL_NAMES,
-    loadConfig: loadMergedOpencodeConfig,
+    loadConfig: (directory) => loadMergedOpencodeConfig(directory, "v2"),
     buildAgentRegistry: (config) => buildAgentRegistry(config)
   })
 };