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

package/dist/index.js

@@ -55,6 +55,7 @@ var V2_TOOLS = {
     name: "subagent",
     input: (input) => defined({
       agent: input.subagent_type ?? input.agent,
+      model: input.model,
       description: input.description,
       prompt: input.prompt,
       sessionID: input.task_id ?? input.sessionID,
@@ -272,6 +273,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 +299,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 +324,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 +373,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 +393,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);
@@ -3225,17 +3253,20 @@ function dispatchTasksFromCalls(calls, batchTasks) {
   const out = [];
   for (const call of calls) {
     if (call.toolName === "task") {
-      out.push(taskFromInput(call.toolCallId, null, call.input));
+      if (!namesOwnModel(call.input)) out.push(taskFromInput(call.toolCallId, null, call.input));
       continue;
     }
     if (call.toolName === "task_batch") {
       for (const [index, task] of batchTasks(call.input).entries()) {
-        out.push(taskFromInput(call.toolCallId, index, task));
+        if (!namesOwnModel(task)) out.push(taskFromInput(call.toolCallId, index, task));
       }
     }
   }
   return out;
 }
+function namesOwnModel(input) {
+  return typeof input.model === "string" && input.model.trim() !== "";
+}
 function taskFromInput(callId, batchIndex, input) {
   return {
     callId,
@@ -4691,6 +4722,13 @@ var TASK_INPUT_PROPERTIES = {
     type: "string",
     description: "The type of specialized agent to use for this task"
   },
+  // After the agent type, where opencode 2's own `subagent` tool puts it
+  // (after `prompt`): first in the list it was the field the model read first.
+  // Stripped on a host whose `task` has no such field (`applyTaskModelSupport`).
+  model: {
+    type: "string",
+    description: "NEVER set this unless the user explicitly asked for a particular model or variant for this subagent. The exact opencode model reference, providerID/modelID, or providerID/modelID#variant to pick a variant. Use only an id the user gave you or one this conversation already used; never guess one. Omit it and opencode picks the model as usual."
+  },
   task_id: {
     type: "string",
     description: "Set this only if you mean to resume a previous task: pass the prior task_id to continue the same subagent session instead of creating a fresh one."
@@ -4713,6 +4751,64 @@ var TASK_INPUT_PROPERTIES = {
 var TASK_INPUT_PROPERTIES_NO_BACKGROUND = Object.fromEntries(
   Object.entries(TASK_INPUT_PROPERTIES).filter(([name]) => name !== "background")
 );
+function liveTaskSupportsModel(taskParameters, dialect = "v1") {
+  if (dialect === "v2") return true;
+  const properties = taskParameters?.properties;
+  if (!properties || typeof properties !== "object") return false;
+  return "model" in properties;
+}
+function applyTaskModelSupport(tools, supported) {
+  if (supported) return tools;
+  const withoutModel = (schema) => {
+    const properties = schema?.properties;
+    if (!properties || typeof properties !== "object") return schema;
+    return {
+      ...schema,
+      properties: Object.fromEntries(
+        Object.entries(properties).filter(([name]) => name !== "model")
+      )
+    };
+  };
+  return tools.map((tool) => {
+    if (tool.name === "task") return { ...tool, inputSchema: withoutModel(tool.inputSchema) };
+    if (tool.name !== TASK_BATCH_TOOL_NAME) return tool;
+    const properties = tool.inputSchema.properties;
+    const tasks = properties?.tasks;
+    if (!tasks?.items || typeof tasks.items !== "object") return tool;
+    return {
+      ...tool,
+      inputSchema: {
+        ...tool.inputSchema,
+        properties: {
+          ...properties,
+          tasks: { ...tasks, items: withoutModel(tasks.items) }
+        }
+      }
+    };
+  });
+}
+function taskSchemaOffersModel(def) {
+  const properties = def.inputSchema.properties;
+  const schema = def.name === TASK_BATCH_TOOL_NAME ? properties?.tasks?.items : def.inputSchema;
+  const fields = schema?.properties;
+  return !!fields && typeof fields === "object" && "model" in fields;
+}
+function taskModelInputError(def, input, guard) {
+  const tasks = def.name === TASK_BATCH_TOOL_NAME ? taskBatchTasks(input) : [input];
+  const offered = taskSchemaOffersModel(def);
+  for (const task of tasks) {
+    if (task.model === void 0) continue;
+    if (!offered) {
+      return "This opencode's task tool takes no per-call `model` (opencode 1.x has none), so no tasks were started. Omit `model`.";
+    }
+    if (typeof task.model !== "string") {
+      return "`model` must be a string, providerID/modelID or providerID/modelID#variant, so no tasks were started.";
+    }
+    const refusal = guard?.(task.model);
+    if (refusal) return refusal;
+  }
+  return null;
+}
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -5005,7 +5101,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         const params = request.params ?? {};
         const toolName = String(params.name ?? "");
         const input = params.arguments ?? {};
-        if (!tools.some((t) => t.name === toolName)) {
+        const tool = tools.find((t) => t.name === toolName);
+        if (!tool) {
           writeJson(res, {
             jsonrpc: "2.0",
             id: requestId,
@@ -5023,6 +5120,13 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
             return;
           }
         }
+        if (toolName === "task" || toolName === TASK_BATCH_TOOL_NAME) {
+          const problem = taskModelInputError(tool, input, options.taskModelGuard);
+          if (problem) {
+            writeToolCallResult(res, requestId, { kind: "error", message: problem });
+            return;
+          }
+        }
         const interceptor = interceptors?.get(toolName);
         if (interceptor) {
           let intercepted;
@@ -5781,6 +5885,112 @@ function clearLedger(sessionId) {
   ledgers.delete(sessionId);
 }
 
+// src/task-model.ts
+var TASK_MODEL_REFERENCE = /^([^/#]+)\/([^#]+)(?:#([^#]+))?$/;
+function parseTaskModelReference(value) {
+  if (typeof value !== "string") return null;
+  const match = TASK_MODEL_REFERENCE.exec(value.trim());
+  if (!match) return null;
+  const [, providerID, modelID, variant] = match;
+  return variant ? { providerID, modelID, variant } : { providerID, modelID };
+}
+function taskModelAccountRefusal(input) {
+  if (!input.groups || input.crossGroup) return null;
+  const reference = parseTaskModelReference(input.model);
+  if (!reference) return null;
+  const target = input.providers.get(reference.providerID);
+  if (target === void 0) return null;
+  if (accountsShareGroup(input.sourceAccount, target, input.groups)) return null;
+  log.notice("task model refused: its account is in another account group", {
+    account: target,
+    reason: "another-account-group"
+  });
+  return `The model "${input.model}" runs on the Claude account "${target}", which is outside this conversation's account group, so no tasks were started. A subagent is handed task text that can quote this conversation, and accountGroups keeps that text inside one group. Omit \`model\`, or name a model on an account in this conversation's group.`;
+}
+var CLAIM_TTL_MS2 = 15 * 6e4;
+var MAX_CLAIMS2 = 512;
+var MAX_SESSION_MODELS = 512;
+var claims2 = [];
+var sessionModels = /* @__PURE__ */ new Map();
+function pruneClaims2(now) {
+  for (let i = claims2.length - 1; i >= 0; i--) {
+    if (now - claims2[i].createdAt > CLAIM_TTL_MS2) claims2.splice(i, 1);
+  }
+  while (claims2.length > MAX_CLAIMS2) claims2.shift();
+}
+function holdSessionModel(sessionId, model) {
+  sessionModels.delete(sessionId);
+  sessionModels.set(sessionId, model);
+  while (sessionModels.size > MAX_SESSION_MODELS) {
+    const oldest = sessionModels.keys().next().value;
+    if (oldest === void 0) break;
+    sessionModels.delete(oldest);
+  }
+}
+function noteExplicitTaskModels(parentSessionId, tasks, now = Date.now()) {
+  let noted = 0;
+  for (const task of tasks) {
+    const reference = parseTaskModelReference(task.model);
+    if (!reference) continue;
+    const resumed = typeof task.task_id === "string" ? task.task_id.trim() : "";
+    if (resumed) {
+      holdSessionModel(resumed, reference);
+      noted++;
+      continue;
+    }
+    if (!parentSessionId || parentSessionId === "default") continue;
+    pruneClaims2(now);
+    claims2.push({
+      parentSessionId,
+      agent: typeof task.subagent_type === "string" ? task.subagent_type : "general",
+      prompt: typeof task.prompt === "string" ? task.prompt : "",
+      model: reference,
+      createdAt: now
+    });
+    noted++;
+  }
+  return noted;
+}
+function explicitTaskModelFor(sessionId) {
+  return sessionModels.get(sessionId);
+}
+function hasExplicitTaskModelCandidate(agent, prompt, now = Date.now()) {
+  if (!agent || prompt === void 0 || claims2.length === 0) return false;
+  pruneClaims2(now);
+  return claims2.some(
+    (claim) => claim.agent === agent && promptMatchesClaim(claim.prompt, prompt)
+  );
+}
+function claimExplicitTaskModel(input) {
+  const held = sessionModels.get(input.sessionId);
+  if (held) return held;
+  if (!input.agent || input.prompt === void 0 || !input.parentSessionId) return void 0;
+  pruneClaims2(input.now ?? Date.now());
+  const belongsHere = (claim2) => claim2.parentSessionId === input.parentSessionId && claim2.agent === input.agent;
+  const childPrompt = input.prompt;
+  let index = claims2.findIndex((claim2) => belongsHere(claim2) && claim2.prompt === childPrompt);
+  if (index === -1) {
+    index = claims2.findIndex(
+      (claim2) => belongsHere(claim2) && promptMatchesClaim(claim2.prompt, childPrompt)
+    );
+  }
+  if (index === -1) return void 0;
+  const [claim] = claims2.splice(index, 1);
+  holdSessionModel(input.sessionId, claim.model);
+  log.info("explicit task model claimed by its child session", {
+    sessionId: input.sessionId,
+    agent: input.agent,
+    model: claim.model.modelID
+  });
+  return claim.model;
+}
+function explicitTaskModelApplies(record, modelId) {
+  return record !== void 0 && record.modelID === modelId;
+}
+function forgetExplicitTaskModel(sessionId) {
+  sessionModels.delete(sessionId);
+}
+
 // src/compression-store.ts
 var MAX_COMPRESSION_ENTRIES = 32;
 var compressions = /* @__PURE__ */ new Map();
@@ -6374,10 +6584,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(
@@ -7732,6 +8003,28 @@ function deleteActiveProcessesForSession(sessionID) {
   for (const key of released) clearBackgroundTasks(key);
   forgetSessionChoice(sessionID);
   forgetDispatchChoicesForSession(sessionID);
+  forgetExplicitTaskModel(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() {
@@ -8373,17 +8666,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 +8734,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 +8747,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 +8956,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 +9047,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.',
@@ -8771,6 +9091,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "subagent dispatch answer was not recognised; dispatching with the defaults",
   "subagent dispatch answer was not recognised; keeping the default",
   "subagent dispatch form was dismissed; dispatching with the defaults",
+  "task model refused: its account is in another account group",
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
   "the interactive turn did not take a forwarded user message",
@@ -14865,7 +15186,7 @@ async function resolvePlanModeQuestion(config, compactionMode, loadLiveToolInfo)
   }
   return active;
 }
-async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCompress, callerSessionId) {
+async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCompress, callerSessionId, sourceAccount) {
   const timeoutOverrides = config.proxyToolTimeoutMs;
   const interceptors = /* @__PURE__ */ new Map();
   if (tools.some((t) => t.name === TASK_STATUS_TOOL_NAME)) {
@@ -14895,8 +15216,25 @@ async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCom
   }
   const cap = config.maxBackgroundSubagents;
   const admit = cap !== void 0 && tools.some((t) => t.name === "task" || t.name === TASK_BATCH_TOOL_NAME) ? (toolName, input) => admitBackgroundDispatch(toolName, input, cap) : void 0;
-  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors, { admit });
+  const accountProviders = accountProviderMap(config.failoverAccounts);
+  const groups = config.accountGroups ?? null;
+  const caller = normalizeAccountName(sourceAccount ?? config.account ?? DEFAULT_ACCOUNT);
+  const taskModelGuard = groups && accountProviders.size > 0 ? (model) => taskModelAccountRefusal({
+    model,
+    sourceAccount: caller,
+    providers: accountProviders,
+    groups,
+    crossGroup: config.subagentDispatchCrossGroup === true
+  }) : void 0;
+  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors, {
+    admit,
+    taskModelGuard
+  });
   srv.calls.on("call", (call) => {
+    if (call.toolName === "task") noteExplicitTaskModels(callerSessionId, [call.input]);
+    else if (call.toolName === TASK_BATCH_TOOL_NAME) {
+      noteExplicitTaskModels(callerSessionId, taskBatchTasks(call.input));
+    }
     queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
   });
   return srv;
@@ -16864,6 +17202,26 @@ var ClaudeCodeLanguageModel = class {
       parentSessionId: await fetchSessionParentId(affinity)
     });
   }
+  /**
+   * The model the parent named for THIS session in its own `task` call, or
+   * undefined (h #g254). The same two lookups as `resolveDispatchChoice`, and
+   * the same reason for the order: a held record first, and the parent fetched
+   * only for a child whose agent and first message match a recorded request.
+   */
+  async resolveExplicitTaskModel(options, affinity) {
+    if (affinity === "default") return void 0;
+    const held = explicitTaskModelFor(affinity);
+    if (held) return held;
+    const agent = this.getOpencodeAgent(options);
+    const prompt = firstUserText(options.prompt);
+    if (!hasExplicitTaskModelCandidate(agent, prompt)) return void 0;
+    return claimExplicitTaskModel({
+      sessionId: affinity,
+      agent,
+      prompt,
+      parentSessionId: await fetchSessionParentId(affinity)
+    });
+  }
   /**
    * Whether the ExitPlanMode approval bridge is live for this turn: the
    * operator opted in AND opencode's registry actually has the `question`
@@ -17037,13 +17395,14 @@ var ClaudeCodeLanguageModel = class {
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
    */
-  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress, callerSessionId) {
+  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress, callerSessionId, sourceAccount) {
     return ensureProxyServer(
       this.config,
       tools,
       sessionKeyForCalls,
       interceptCompress,
-      callerSessionId
+      callerSessionId,
+      sourceAccount
     );
   }
   /**
@@ -17064,12 +17423,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 +17471,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);
   }
@@ -17443,17 +17793,19 @@ var ClaudeCodeLanguageModel = class {
     const affinity = this.sessionAffinity(options);
     const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const compactionMode = this.isCompactionCall(options);
-    const dispatchChoice = compactionMode ? void 0 : await this.resolveDispatchChoice(options, affinity);
+    const explicitTaskModel = compactionMode ? void 0 : await this.resolveExplicitTaskModel(options, affinity);
+    const explicitModelApplies = explicitTaskModelApplies(explicitTaskModel, this.modelId);
+    const dispatchChoice = compactionMode || explicitModelApplies ? void 0 : await this.resolveDispatchChoice(options, affinity);
     const dispatchModelId = dispatchChoice?.model ? qualifyModelName(dispatchChoice.model, this.modelId) : null;
-    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : attempt?.modelOverride ?? dispatchModelId ?? resolveAgentModel(
+    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : attempt?.modelOverride ?? dispatchModelId ?? (explicitModelApplies ? this.modelId : resolveAgentModel(
       this.getOpencodeAgent(options),
       this.modelId
-    );
+    ));
     if (attempt) attempt.modelId = effectiveModelId;
-    const reasoningEffort = compactionMode ? void 0 : dispatchChoice?.effort ?? resolveAgentEffort(
+    const reasoningEffort = compactionMode ? void 0 : dispatchChoice?.effort ?? (explicitModelApplies && explicitTaskModel?.variant ? this.getReasoningEffort(options.providerOptions) : resolveAgentEffort(
       this.getOpencodeAgent(options),
       this.getReasoningEffort(options.providerOptions)
-    );
+    ));
     const promptCacheTtl = compactionMode ? void 0 : resolveAgentCacheTtl(this.getOpencodeAgent(options));
     const context = [
       this.config.provider,
@@ -18483,6 +18835,16 @@ var ClaudeCodeLanguageModel = class {
                 backgroundSubagentsSupported,
                 hostDialect
               );
+              const taskModelSupported = liveTaskSupportsModel(
+                liveToolInfo.taskParameters,
+                hostDialect
+              );
+              enrichedProxy = applyTaskModelSupport(enrichedProxy, taskModelSupported);
+              log.info("task model gate", {
+                supported: taskModelSupported,
+                registryResolved: liveToolInfo.resolved,
+                hostApi: hostDialect
+              });
               recordBackgroundSubagentGate({
                 supported: backgroundSubagentsSupported,
                 hostApi: hostDialect,
@@ -18537,7 +18899,8 @@ var ClaudeCodeLanguageModel = class {
                 combinedProxyTools,
                 sk,
                 pluginCompressEnabled,
-                affinity
+                affinity,
+                sourceAccount
               );
             }
             const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
@@ -19295,38 +19658,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 +20119,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 +20162,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 +20211,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,25 +20503,90 @@ 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) => {
     if (!isOpencodeV2Context(ctx)) {
@@ -20137,9 +20596,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 +20622,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 +20677,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 +20695,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 +20724,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,