@khalilgharbaoui/opencode-claude-code-plugin 0.58.0 → 0.59.0

package/dist/index.d.ts

@@ -128,13 +128,26 @@ interface V2CommandDefinition {
     readonly description?: string;
     readonly execute: (input: V2CommandInvocation) => Promise<void>;
 }
-/** `session.deleted` is the one event this plugin acts on. */
+/**
+ * A bus event. Acted on: `session.deleted`, `session.execution.started` /
+ * `succeeded` / `failed` / `interrupted` (with `reason`, measured on 2.0.31,
+ * h #g253), and the never-emitted-there `session.status` / `session.idle`.
+ */
 interface V2Event {
     readonly type?: string;
     readonly data?: {
         readonly sessionID?: string;
     } & Record<string, unknown>;
 }
+/**
+ * `ctx.rpc.register`'s result (`@opencode/plugin` 2.0.31 `RpcRegistration`):
+ * a registration whose events travel on the bus as `rpc.<id>.<event>`.
+ */
+interface V2RpcRegistration extends V2Registration {
+    readonly events: {
+        emit(name: string, data: Record<string, unknown>): Promise<void>;
+    };
+}
 interface V2Context {
     readonly app: {
         readonly version: string;
@@ -167,6 +180,14 @@ interface V2Context {
             signal?: AbortSignal;
         }): AsyncIterable<V2Event>;
     };
+    /**
+     * Absent before 2.0.31's measured shape: the definition is plain JSON
+     * Schema, which `Rpc.PortableDefinition` accepts, and the handlers object is
+     * empty because the definition declares no methods.
+     */
+    readonly rpc?: {
+        register(definition: unknown, handlers: Record<string, never>): Promise<V2RpcRegistration>;
+    };
     readonly skill?: {
         transform(callback: (editor: {
             get(id: string): unknown;
@@ -1549,8 +1570,6 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      *   3. `"default"`.
      */
     private sessionAffinity;
-    private controlRequestBehaviorForTool;
-    private writeControlResponse;
     /**
      * Handle Claude stream-json control requests (`can_use_tool`, etc.) and
      * respond via stdin with a matching `control_response`.
@@ -1567,7 +1586,6 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      */
     private resolveCompactionModel;
     private thinkingCliOptions;
-    private latestUserText;
     private synthesizeTitle;
     /**
      * Aggregates the one turn implementation into a `doGenerate` result.

package/dist/index.js

@@ -272,6 +272,8 @@ var MAX_TOASTED_MESSAGES = 200;
 var toastBurstLimit = 3;
 var toastBurstWindowMs = 2e3;
 var activeSink = null;
+var activeNotifier = null;
+var bufferedNotices = [];
 var bufferedEntries = [];
 var droppedBeforeSink = 0;
 var toastedMessages = /* @__PURE__ */ new Set();
@@ -296,6 +298,13 @@ function setLogSink(sink) {
     });
   }
 }
+function setToastNotifier(notifier) {
+  activeNotifier = notifier;
+  if (!notifier) return;
+  const pending2 = bufferedNotices;
+  bufferedNotices = [];
+  for (const entry of pending2) maybeToast(entry, notifier);
+}
 function routeToSink(entry) {
   if (!activeSink) {
     if (bufferedEntries.length >= MAX_BUFFERED_SINK_ENTRIES) {
@@ -314,18 +323,34 @@ function deliverToSink(entry) {
     sink.log(entry);
   } catch {
   }
+  maybeToast(entry, (toast) => sink.toast(toast));
+}
+function maybeToast(entry, send) {
   if (entry.level !== "warn" && entry.level !== "error") return;
   if (toastedMessages.has(entry.message)) return;
   if (toastedMessages.size < MAX_TOASTED_MESSAGES) toastedMessages.add(entry.message);
   if (!allowToastNow()) return;
-  sendToast(sink, entry);
+  sendToast(send, entry);
 }
-function sendToast(sink, entry) {
+function sendToast(send, entry) {
   try {
-    sink.toast(entry);
+    send(entry);
   } catch {
   }
 }
+function toastTarget() {
+  const sink = activeSink;
+  if (sink) return (entry) => sink.toast(entry);
+  return activeNotifier;
+}
+function routeToNotifier(entry) {
+  const notifier = activeNotifier;
+  if (notifier) {
+    maybeToast(entry, notifier);
+    return;
+  }
+  if (bufferedNotices.length < MAX_BUFFERED_SINK_ENTRIES) bufferedNotices.push(entry);
+}
 function allowToastNow() {
   const now = Date.now();
   if (now - burstWindowStart >= toastBurstWindowMs) {
@@ -347,10 +372,11 @@ function armBurstSummary() {
     const suppressed = burstSuppressed;
     burstSuppressed = 0;
     if (suppressed <= 0) return;
-    const sink = activeSink;
-    if (!sink) return;
-    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in opencode's log`;
-    sendToast(sink, { level: "warn", message, line: fmt("WARN", message) });
+    const target = toastTarget();
+    if (!target) return;
+    const where = activeSink ? "opencode's log" : "the plugin log file";
+    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in ${where}`;
+    sendToast(target, { level: "warn", message, line: fmt("WARN", message) });
   }, toastBurstWindowMs);
   burstSummaryTimer.unref?.();
 }
@@ -366,6 +392,7 @@ function emit(level, msg, data) {
       routeToSink({ level, message: msg, data, line });
     } else {
       console.error(line);
+      if (level === "warn" || level === "error") routeToNotifier({ level, message: msg, data, line });
     }
   }
   writeToFile(line);
@@ -6374,10 +6401,71 @@ function watchChildSession(sessionID) {
   });
   return () => answer;
 }
+var eventRunStates = /* @__PURE__ */ new Map();
+var MAX_EVENT_RUN_STATES = 512;
+var openEventFeeds = 0;
+function openSessionRunEventFeed() {
+  openEventFeeds += 1;
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    openEventFeeds = Math.max(0, openEventFeeds - 1);
+    eventRunStates.clear();
+  };
+}
+function noteSessionRunEvent(event) {
+  if (openEventFeeds === 0 || !event || typeof event !== "object") return;
+  const { type, data } = event;
+  if (typeof type !== "string" || !data || typeof data !== "object") return;
+  const sessionID = data.sessionID;
+  if (typeof sessionID !== "string" || !sessionID || sessionID === "default") return;
+  if (type === "session.deleted") {
+    eventRunStates.delete(sessionID);
+    return;
+  }
+  let next;
+  switch (type) {
+    case "session.execution.started":
+      next = "busy";
+      break;
+    case "session.execution.succeeded":
+    case "session.execution.failed":
+    case "session.execution.interrupted":
+    case "session.idle":
+      next = "idle";
+      break;
+    case "session.status": {
+      const status = data.status?.type;
+      if (typeof status === "string") next = status === "idle" ? "idle" : "busy";
+      break;
+    }
+  }
+  if (!next) return;
+  eventRunStates.delete(sessionID);
+  eventRunStates.set(sessionID, next);
+  while (eventRunStates.size > MAX_EVENT_RUN_STATES) {
+    const oldest = eventRunStates.keys().next().value;
+    if (oldest === void 0) break;
+    eventRunStates.delete(oldest);
+  }
+}
+function sessionRunStateFromEvents(sessionID) {
+  if (openEventFeeds === 0) return "unknown";
+  return eventRunStates.get(sessionID) ?? "unknown";
+}
+function busySessionsFromEvents() {
+  if (openEventFeeds === 0) return void 0;
+  const busy = {};
+  for (const [sessionID, state] of eventRunStates) {
+    if (state === "busy") busy[sessionID] = { type: "busy" };
+  }
+  return busy;
+}
 async function fetchSessionRunState(sessionID, directory) {
   if (!sessionID || sessionID === "default") return "unknown";
   const status = opencodeClient?.session?.status;
-  if (!status) return "unknown";
+  if (!status) return sessionRunStateFromEvents(sessionID);
   try {
     const dir = directory ?? await fetchSessionDirectory(sessionID);
     const res = await status.call(
@@ -7734,6 +7822,27 @@ function deleteActiveProcessesForSession(sessionID) {
   forgetDispatchChoicesForSession(sessionID);
   return released;
 }
+var STOPPED_TURN_MESSAGE = "opencode stopped the turn while it was running its proxy tool calls";
+function releaseParkedProxyCallsForSession(sessionID, reason = STOPPED_TURN_MESSAGE) {
+  if (!sessionID || sessionID === "default") return [];
+  const released = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    const owned = ap.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+    if (!owned) continue;
+    if (ap.lineEmitter.listenerCount("line") > 0) continue;
+    if (getPendingProxyCalls(key).length === 0) continue;
+    log.info("opencode stopped the turn at a proxy tool boundary; releasing pending calls", {
+      sessionKey: key,
+      sessionID
+    });
+    void interruptTurn(ap).then((idle) => {
+      log.info("interrupt sent for aborted turn", { sk: key, idle });
+    });
+    rejectAllPendingProxyCallsForSession(key, new Error(reason));
+    released.push(key);
+  }
+  return released;
+}
 function killAllActiveProcesses() {
   const keys = [...activeProcesses.keys()];
   for (const key of keys) deleteActiveProcess(key);
@@ -8373,17 +8482,14 @@ async function fetchAsideHistory(client, sessionID, question) {
     return [];
   }
 }
-async function handleBtwCommand(client, input, options = {}) {
+async function runBtwCommand(client, input, options = {}) {
   const question = input.arguments.trim();
-  if (!question) {
-    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
-    throw new BtwHandledError("/btw needs a question.");
-  }
+  if (!question) return "bare";
   const active = await waitForAsideProcess(client, input.sessionID, options);
   const transport = active?.asideTransport;
   if (!active || !transport) {
     if (active) log.info("btw: process has no aside transport, leaving it to the turn", { sessionID: input.sessionID });
-    return;
+    return "release";
   }
   let busy = false;
   let inlineDone = false;
@@ -8444,7 +8550,7 @@ async function handleBtwCommand(client, input, options = {}) {
       }
     );
   }
-  if (!busy) return;
+  if (!busy) return "release";
   const started2 = Date.now();
   const outcome = await Promise.race([
     inlineDelivered,
@@ -8457,18 +8563,46 @@ async function handleBtwCommand(client, input, options = {}) {
       sessionID: input.sessionID,
       waitedMs: Date.now() - started2
     });
-    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
+    return "inline";
   }
   log.info("btw: turn over, releasing the /btw message", {
     sessionID: input.sessionID,
     idle: outcome === "idle",
     waitedMs: Date.now() - started2
   });
+  return outcome === "timeout" ? "timeout" : "release";
+}
+async function handleBtwCommand(client, input, options = {}) {
+  const outcome = await runBtwCommand(client, input, options);
+  if (outcome === "bare") {
+    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
+    throw new BtwHandledError("/btw needs a question.");
+  }
+  if (outcome === "inline") throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
   if (outcome === "timeout") {
     showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
     throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
   }
 }
+async function askBtwThenRelease(client, input, release2, options = {}) {
+  let outcome;
+  try {
+    outcome = await runBtwCommand(client, input, options);
+  } catch (error) {
+    log.warn("btw: the early aside failed; sending the /btw message as it is", {
+      sessionID: input.sessionID,
+      error: errorText(error)
+    });
+    outcome = "failed";
+  }
+  if (outcome === "inline") return outcome;
+  try {
+    await release2();
+  } catch (error) {
+    log.warn("btw: could not send the /btw message", { sessionID: input.sessionID, error: errorText(error) });
+  }
+  return outcome;
+}
 
 // src/budget-ledger.ts
 var BUDGET_MARKER = "\u258C **budget:**";
@@ -8638,7 +8772,9 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "automatic account switch skipped an account whose runtime could not be prepared",
   "background dispatch refused by maxBackgroundSubagents",
   "btw: a turn is running but no claude process appeared for it",
+  "btw: could not send the /btw message",
   "btw: early aside failed; the message will ask again",
+  "btw: the early aside failed; sending the /btw message as it is",
   "budget option refused: not a positive number of dollars",
   "budgetWarnAt refused: expected percentages between 0 and 100",
   "cannot interrupt this transport; waiting for the turn to end",
@@ -8727,7 +8863,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "no configured account could take this turn; it ends here",
   "no proxyTools entry was recognised; nothing will be proxied this turn",
   "no stdout after envelope write; respawning claude process to resume conversation",
-  "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction",
+  "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction, and stopped turns keep their proxy calls until the next message",
   "opencode's stored OAuth token for this MCP server has expired, so the bridged server carries no credential; re-authenticate it in opencode",
   "pending proxy call arrived after stream close; rejecting",
   'permissionMode "plan" is enforced: claude cannot edit files or run commands, and --dangerously-skip-permissions is deliberately not passed so it stays that way. Headless Claude Code is not offered an ExitPlanMode tool, so nothing releases plan mode mid-session; approving a plan in chat does not unlock writes. Leaving plan mode means changing the config and restarting opencode.',
@@ -17064,12 +17200,6 @@ var ClaudeCodeLanguageModel = class {
       this.config.provider
     );
   }
-  controlRequestBehaviorForTool(toolName) {
-    return controlRequestBehaviorForTool(this.config, toolName);
-  }
-  writeControlResponse(proc, requestId, response) {
-    writeControlResponse(proc, requestId, response);
-  }
   /**
    * Handle Claude stream-json control requests (`can_use_tool`, etc.) and
    * respond via stdin with a matching `control_response`.
@@ -17118,9 +17248,6 @@ var ClaudeCodeLanguageModel = class {
       thinkingDisplay: process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0 ? "summarized" : void 0
     };
   }
-  latestUserText(prompt) {
-    return latestUserText(prompt);
-  }
   synthesizeTitle(prompt) {
     return synthesizeTitle(prompt);
   }
@@ -19295,38 +19422,40 @@ var ClaudeCodeLanguageModel = class {
                 dropped: unattended.dropped
               });
               let partialText = false;
-              {
+              const narration = [];
+              for (const line of unattended.lines) {
+                try {
+                  const outer = JSON.parse(line);
+                  const msg = outer.type === "stream_event" && outer.event ? outer.event : outer;
+                  let text = "";
+                  if (msg.type === "content_block_delta" && msg.delta?.type === "text_delta") {
+                    text = msg.delta.text ?? "";
+                    partialText = true;
+                  } else if (msg.type === "assistant") {
+                    if (!partialText) text = (msg.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+                    partialText = false;
+                  } else if (msg.type === "result") {
+                    state.unattendedTurnEnded = true;
+                    for (const entry of state.activeProcess.pendingProxyCompletions?.values() ?? []) {
+                      if (isPendingProxyCallChannelClosed(entry.call)) entry.recoveryRequired = true;
+                    }
+                    if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
+                    if (msg.is_error && msg.result) text = msg.result;
+                  }
+                  if (text) narration.push(text);
+                } catch {
+                }
+              }
+              if (narration.length > 0 || unattended.dropped > 0) {
                 const replayId = state.startTextBlock();
                 controller.enqueue({
                   type: "text-delta",
                   id: replayId,
                   delta: formatUnattendedReplayNote(unattended.dropped)
                 });
-                for (const line of unattended.lines) {
-                  try {
-                    const outer = JSON.parse(line);
-                    const msg = outer.type === "stream_event" && outer.event ? outer.event : outer;
-                    let text = "";
-                    if (msg.type === "content_block_delta" && msg.delta?.type === "text_delta") {
-                      text = msg.delta.text ?? "";
-                      partialText = true;
-                    } else if (msg.type === "assistant") {
-                      if (!partialText) text = (msg.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
-                      partialText = false;
-                    } else if (msg.type === "result") {
-                      state.unattendedTurnEnded = true;
-                      for (const entry of state.activeProcess.pendingProxyCompletions?.values() ?? []) {
-                        if (isPendingProxyCallChannelClosed(entry.call)) entry.recoveryRequired = true;
-                      }
-                      if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
-                      if (msg.is_error && msg.result) text = msg.result;
-                    }
-                    if (text) controller.enqueue({ type: "text-delta", id: state.currentTextId ?? state.startTextBlock(), delta: text });
-                  } catch {
-                  }
-                }
+                for (const text of narration) controller.enqueue({ type: "text-delta", id: replayId, delta: text });
+                state.endTextBlock();
               }
-              state.endTextBlock();
               clearFallbackTimer(state);
               state.hasReceivedContent = false;
             }
@@ -19754,11 +19883,42 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
-// src/tui-log-sink.ts
-var LOG_SERVICE_NAME = "opencode-claude-code";
+// src/plugin-notice.ts
+var NOTICE_RPC_ID = "opencode-claude-code-plugin";
+var NOTICE_EVENT = "notice";
+var NOTICE_EVENT_TYPE = `rpc.${NOTICE_RPC_ID}.${NOTICE_EVENT}`;
+var NOTICE_RPC_DEFINITION = {
+  id: NOTICE_RPC_ID,
+  methods: {},
+  events: {
+    [NOTICE_EVENT]: {
+      schema: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          level: { type: "string", enum: ["warn", "error"] },
+          message: { type: "string" }
+        },
+        required: ["id", "level", "message"],
+        additionalProperties: false
+      }
+    }
+  }
+};
 var TOAST_TITLE = "claude-code";
 var TOAST_DURATION_MS = 1e4;
 var MAX_TOAST_CHARS = 240;
+function toastMessage(message) {
+  const flat = message.replace(/\s+/g, " ").trim();
+  if (flat.length <= MAX_TOAST_CHARS) return flat;
+  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
+}
+function pluginNotice(id, level, message) {
+  return { id, level, message: toastMessage(message) };
+}
+
+// src/tui-log-sink.ts
+var LOG_SERVICE_NAME = "opencode-claude-code";
 var APP_LOG_LEVEL = {
   debug: "debug",
   info: "info",
@@ -19766,11 +19926,6 @@ var APP_LOG_LEVEL = {
   warn: "warn",
   error: "error"
 };
-function toastMessage(message) {
-  const flat = message.replace(/\s+/g, " ").trim();
-  if (flat.length <= MAX_TOAST_CHARS) return flat;
-  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
-}
 function appLogBody(entry) {
   return {
     service: LOG_SERVICE_NAME,
@@ -19820,6 +19975,9 @@ function registerOpencodeLogSink(client) {
   return true;
 }
 
+// src/v2.ts
+import { randomUUID as randomUUID8 } from "crypto";
+
 // src/v2-client.ts
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
@@ -20109,24 +20267,89 @@ function deletedSessionIdV2(event) {
   const id = event.data?.sessionID;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
-async function releaseDeletedSessions(subscribe, signal) {
+function stoppedSessionIdV2(event) {
+  if (!event || event.type !== "session.execution.interrupted") return void 0;
+  if (event.data?.reason !== "user") return void 0;
+  const id = event.data?.sessionID;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+async function followSessionEvents(subscribe, signal) {
+  const closeFeed = openSessionRunEventFeed();
   try {
     for await (const event of subscribe({ signal })) {
       if (signal.aborted) break;
-      const sessionID = deletedSessionIdV2(event);
-      if (!sessionID) continue;
-      const released = deleteActiveProcessesForSession(sessionID);
-      if (released.length > 0) {
-        log.info("released claude state for deleted session", { sessionID, released });
+      noteSessionRunEvent(event);
+      const deleted = deletedSessionIdV2(event);
+      if (deleted) {
+        const released = deleteActiveProcessesForSession(deleted);
+        if (released.length > 0) {
+          log.info("released claude state for deleted session", { sessionID: deleted, released });
+        }
+        continue;
       }
+      const stopped = stoppedSessionIdV2(event);
+      if (stopped) releaseParkedProxyCallsForSession(stopped);
     }
   } catch (err) {
     if (!signal.aborted) {
-      log.warn("opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction", {
-        error: err instanceof Error ? err.message : String(err)
-      });
+      log.warn(
+        "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction, and stopped turns keep their proxy calls until the next message",
+        { error: err instanceof Error ? err.message : String(err) }
+      );
     }
+  } finally {
+    closeFeed();
+  }
+}
+var noticeEmitters = /* @__PURE__ */ new Set();
+var NOTICE_PROCESS_TAG = randomUUID8().slice(0, 8);
+var noticeCounter = 0;
+function emitNotice(entry) {
+  if (entry.level !== "warn" && entry.level !== "error") return;
+  noticeCounter += 1;
+  const notice = pluginNotice(`${NOTICE_PROCESS_TAG}-${noticeCounter}`, entry.level, entry.message);
+  for (const emit2 of noticeEmitters) emit2(notice);
+}
+async function registerNoticeChannel(ctx) {
+  const rpc = ctx.rpc;
+  if (typeof rpc?.register !== "function") return void 0;
+  let registration;
+  try {
+    registration = await rpc.register(NOTICE_RPC_DEFINITION, {});
+  } catch (err) {
+    log.debug("opencode 2 refused the notice channel; warnings stay in the plugin log", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
   }
+  const emitter2 = (notice) => {
+    try {
+      void Promise.resolve(registration.events.emit(NOTICE_EVENT, { ...notice })).catch(() => void 0);
+    } catch {
+    }
+  };
+  noticeEmitters.add(emitter2);
+  setToastNotifier(emitNotice);
+  return {
+    dispose: async () => {
+      noticeEmitters.delete(emitter2);
+      if (noticeEmitters.size === 0) setToastNotifier(null);
+      await registration.dispose();
+    }
+  };
+}
+function v2BtwClient(shim) {
+  const shimSession = shim.session;
+  const messages = shimSession?.messages;
+  const status = async () => ({ data: busySessionsFromEvents() ?? {} });
+  return {
+    session: {
+      ...typeof messages === "function" ? { messages: (options) => messages.call(shimSession, options) } : {},
+      get status() {
+        return busySessionsFromEvents() === void 0 ? void 0 : status;
+      }
+    }
+  };
 }
 function createV2Setup(deps) {
   return async (ctx) => {
@@ -20137,9 +20360,13 @@ function createV2Setup(deps) {
       return () => void 0;
     }
     ensureProcessExitCleanup();
-    setOpencodeClient(createV1ClientShim(ctx));
+    const shim = createV1ClientShim(ctx);
+    setOpencodeClient(shim);
     const directory = ctx.location?.directory;
     setOpencodeProjectDirectory(isUsableDirectory(directory) ? directory : void 0);
+    const registrations = [];
+    const noticeChannel = await registerNoticeChannel(ctx);
+    if (noticeChannel) registrations.push(noticeChannel);
     if (deps.buildAgentRegistry) {
       try {
         const config = deps.loadConfig(directory ?? process.cwd());
@@ -20159,7 +20386,6 @@ function createV2Setup(deps) {
       }
     }
     const planned = /* @__PURE__ */ new Map();
-    const registrations = [];
     registrations.push(
       await ctx.provider.transform((editor) => {
         const seed = editor.get(BASE_PROVIDER_ID);
@@ -20215,6 +20441,7 @@ function createV2Setup(deps) {
       })
     );
     const prompt = ctx.session.prompt;
+    const btwClient = v2BtwClient(shim);
     if (ctx.command?.transform && typeof prompt === "function") {
       const send = (input, command, delivery) => prompt.call(ctx.session, {
         ...input.prompt,
@@ -20232,7 +20459,15 @@ function createV2Setup(deps) {
           editor.add({
             name: "btw",
             description: BTW_COMMAND_DESCRIPTION,
-            execute: (input) => send(input, "btw", "queue")
+            execute: (input) => {
+              void askBtwThenRelease(
+                btwClient,
+                { command: "btw", sessionID: input.sessionID, arguments: input.prompt.text ?? "" },
+                () => send(input, "btw", "queue"),
+                deps.btwWaitOptions
+              );
+              return Promise.resolve();
+            }
           });
         })
       );
@@ -20253,7 +20488,7 @@ function createV2Setup(deps) {
     }
     const events = new AbortController();
     if (typeof ctx.event?.subscribe === "function") {
-      void releaseDeletedSessions(ctx.event.subscribe.bind(ctx.event), events.signal);
+      void followSessionEvents(ctx.event.subscribe.bind(ctx.event), events.signal);
     }
     log.info("claude-code plugin set up for opencode 2", {
       opencode: ctx.app?.version,