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

package/README.md

@@ -541,7 +541,7 @@ Anything you supply is merged on top of the defaults; you don't need to redeclar
 
 ## Interactive transport (experimental)
 
-By default the plugin spawns `claude --print` (headless). The interactive transport instead drives the real interactive `claude` TUI under a native PTY inside opencode's Bun runtime, types your prompt into it, and streams the session transcript (`~/.claude/projects/<cwd>/<session-id>.jsonl`) back through the same pipeline the headless transport uses. It was built as insurance for the day headless usage is billed differently from interactive usage; today both draw from the same plan usage limits (see [Billing](#billing)), so it is not a way to change what a turn costs.
+By default the plugin spawns `claude --print` (headless). The interactive transport instead drives the real interactive `claude` TUI under a native PTY inside opencode's Bun runtime, types your prompt into it, and streams the session transcript (`~/.claude/projects/<encoded-cwd>/<session-id>.jsonl`) back through the same pipeline the headless transport uses. Claude Code names that directory from the cwd's **resolved real path** with every non-alphanumeric character replaced by `-`, so a working directory reached through a symlink (on macOS `/tmp` is a symlink to `/private/tmp`) is named after the target: `/tmp/scratch` becomes `-private-tmp-scratch`. It was built as insurance for the day headless usage is billed differently from interactive usage; today both draw from the same plan usage limits (see [Billing](#billing)), so it is not a way to change what a turn costs.
 
 ```json
 "options": { "interactive": true }
@@ -577,6 +577,7 @@ This is the part to read before turning it on. Three whole features of this plug
 - **Input is text-only:** images and other non-text blocks are dropped (with a logged warning); tool results are rendered as labeled text.
 - **Output granularity:** text arrives per transcript record, not token-by-token, so it can feel chunkier than headless streaming.
 - **Token counts come from the transcript, one count per API call.** The session JSONL writes one record per content block (thinking, text, tool_use) and every record of a call repeats that call's final usage, so the transport counts each call once, keyed by its message id. The numbers then mean exactly what they do on the headless transport: [`turnStats`](#per-turn-stats) gets the turn's totals and opencode gets the last call's context plus the turn's output. Before this was fixed a four-tool turn reported 1,306 output tokens against a real 653, and its input and cache counts were one call's instead of the turn's. An all-zero `<synthetic>` record (how the CLI writes "Login expired" or a session limit into the transcript) is not counted as a call.
+- **How a turn finishes:** a turn that reaches a terminal stop reason (`end_turn`, `stop_sequence`, `max_tokens`) finishes exactly as a headless turn does, so it is an ordinary completed reply and [`turnStats`](#per-turn-stats) applies to it. `max_tokens` is deliberately a completed turn rather than a failure: the call happened and billed, and the truncation is what auto-continue reads. Before this was fixed every interactive turn finished as an error instead, which also suppressed the stats footer.
 - **Turn timeout:** a turn that produces no terminal stop within 30 minutes is reported honestly as an error result (visible truncation), not silently ended.
 - **No idle eviction:** `idleProcessTimeoutMs` does not apply to interactive sessions.
 - `/compact` always uses the headless transport regardless of this setting.
@@ -646,6 +647,14 @@ The task is working in the background. You will be notified automatically when i
 
 Claude keeps working. When the subagent finishes, opencode prompts the same conversation with the result as a new message, so it arrives as its own turn rather than as that call's result. Measured end to end on opencode 1.18.33 with claude-haiku-4-5: the dispatch returned in 14 s while the child's 30-second command was still running, Claude ran another tool and ended its turn 18 s in, and the `<task ... state="completed">` message landed 43 s later. That notification is automatic, so the right thing after a background dispatch is to end the turn, not to wait or poll.
 
+**opencode 2 uses different envelopes for the same thing**, so the plugin tells the model about its own host's. There a background dispatch answers in prose rather than XML:
+
+```text
+The subagent is working in the background (sessionID: ses_f0cb9005fffekrDPNa1Px8Jp0J). You will be notified automatically when it finishes.
+```
+
+and the completion arrives as `<subagent sessionID="…" state="completed" description="…">`. That `sessionID` is the `task_id` for the two tools below. Measured on opencode 2.0.16.
+
 **The gate is enforced at the schema, not at the call.** On a host without the flag opencode rejects `background: true` outright with `Background subagents require OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true`, which costs a whole dispatch. So the plugin reads the host's own `task` schema (the same registry fetch that supplies the agent-type list) and, when it has no `background` property, strips the field before Claude ever sees it. Nothing about a default install changes: the model is shown exactly `description`, `prompt`, `subagent_type`, `task_id`, `command`. Either way `plugin.log` says which:
 
 ```
@@ -659,7 +668,11 @@ background subagent gate {"supported":true,"registryResolved":true,"hostApi":"v1
 | `mcp__opencode_proxy__task_status` | Reads the state of a background subagent by its `task_id` and returns its result if it has finished. A recovery path, not a progress poll: a healthy background task delivers its own result. A result is handed over once, so asking again reports the state without repeating the output. |
 | `mcp__opencode_proxy__task_cancel` | Stops a background subagent. A cancelled subagent sends no completion notification. |
 
-The `task_id` is the `id` in the `<task …>` envelope, which is the child's own opencode session id. Both tools are answered inside the plugin rather than executed by opencode, because opencode has no tools of these names, and both refuse any session whose parent is not the conversation doing the asking. Neither can be named in `proxyTools`: they appear only when the host advertises background support, so upgrading changes nothing about what the model can do or spend on a default install.
+The `task_id` is the child's own opencode session id: the `id` in the `<task …>` envelope on opencode 1.x, the `sessionID` the dispatch reported on opencode 2. Both tools are answered inside the plugin rather than executed by opencode, because opencode has no tools of these names, and both refuse any session whose parent is not the conversation doing the asking. Neither can be named in `proxyTools`: they appear only when the host advertises background support, so upgrading changes nothing about what the model can do or spend on a default install.
+
+Both work on opencode 1.x and on opencode 2. On opencode 2 they run over the session routes a plugin is actually given there (`session.context` and `session.interrupt`); opencode 2 gives a plugin no all-sessions run-state map, so "still running" is read off the child's own transcript instead. Verified live on 2.0.16: start, `task_status` answering `running`, `task_cancel` answering `Stopped.`, and a finished child collected once.
+
+**What `/claude-code-doctor` says about it.** The report has a **Background subagents** section: whether `background` was offered to Claude and the two tools registered, which opencode major, and what decided it (the live `task` schema, a registry that did not answer, or opencode 2 offering it unconditionally), plus the background tasks this process has collected or cancelled. The gate is read while a turn plans its proxy tools, so in a fresh process the section reads `Not read yet this process`: send one message and run it again.
 
 ### Proxy endpoint security
 

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) };
   });
@@ -3132,8 +3134,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 +3151,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 +3174,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 +3205,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 +3240,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 +3295,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 +3307,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>"
   };
 }
 
@@ -5219,6 +5251,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 +5287,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 +5406,11 @@ async function gatherDoctorReport(options) {
     proxyServers,
     mcpServerErrors: snapshotMcpServerErrors(),
     pluginLoadFailures: snapshotPluginLoadFailures(),
-    planUsage
+    planUsage,
+    backgroundSubagents: {
+      gate: snapshotBackgroundSubagentGate(),
+      ledgers: snapshotBackgroundTasks()
+    }
   };
 }
 async function buildDoctorReport(options) {
@@ -5332,7 +5425,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 +6914,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 +7441,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 +7475,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 {
@@ -10547,18 +10653,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"
                 });
               }
@@ -11203,7 +11316,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 +11355,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 +11424,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 +11497,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;
@@ -11436,13 +11573,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;
 }