agentbox-sdk 0.1.508 → 0.1.511

package/dist/{chunk-BO4J4KSM.js → chunk-G3VEVR6Y.js}

@@ -1825,8 +1825,203 @@ function extractOpenCodeCostData(events) {
   }) : null;
 }
 
+// src/agents/background-tasks.ts
+var DEFAULT_BACKGROUND_TASK_TIMEOUT_MS = 30 * 6e4;
+var BACKGROUND_TASK_GRACE_MS = 15e3;
+var CLI_BACKGROUND_WAIT_CEILING_ENV = "CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS";
+var CLI_BACKGROUND_WAIT_CEILING_MS = 3e4;
+function resolveBackgroundTaskTimeoutMs(value) {
+  if (value === void 0) return DEFAULT_BACKGROUND_TASK_TIMEOUT_MS;
+  if (Number.isNaN(value) || value < 0) {
+    throw new Error(
+      "backgroundTaskTimeoutMs must be a non-negative number (Infinity waits forever)."
+    );
+  }
+  return value;
+}
+function applyCliBackgroundWaitCeiling(env) {
+  env[CLI_BACKGROUND_WAIT_CEILING_ENV] ??= String(
+    CLI_BACKGROUND_WAIT_CEILING_MS
+  );
+}
+function asRecord2(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+var SCHEDULE_TOOLS = /* @__PURE__ */ new Set(["CronCreate", "ScheduleWakeup"]);
+var DONE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "killed"]);
+var BackgroundTaskTracker = class {
+  tasks = /* @__PURE__ */ new Map();
+  wakeups = /* @__PURE__ */ new Map();
+  // tool_use seen, tool_result not yet: a failed schedule adds nothing.
+  pendingWakeups = /* @__PURE__ */ new Map();
+  afterResult = false;
+  seenBackgroundWork = false;
+  liveTasks() {
+    return [...this.tasks.values(), ...this.wakeups.values()];
+  }
+  /**
+   * True once any background task or scheduled wakeup was live in this run.
+   * The CLI queues a wake-up for every task that finishes and delivers it as
+   * a new turn once the model is idle — including tasks that finished
+   * mid-turn, whose queued turn starts right after that turn's `result`
+   * with nothing live and nothing observable in between. After background
+   * work has been seen, a `result` is therefore never the end of the run on
+   * its own; only the grace passing without a new turn is.
+   */
+  hasSeenBackgroundWork() {
+    return this.seenBackgroundWork;
+  }
+  /** Feed one SDKMessage. Returns true when it started a follow-up turn. */
+  ingest(message) {
+    const m = asRecord2(message);
+    if (!m) return false;
+    if (m.type === "result") {
+      this.afterResult = true;
+      return false;
+    }
+    if (m.type === "system") return this.ingestSystem(m);
+    if (m.type === "command_lifecycle") {
+      if (m.state !== "started") return false;
+      this.wakeups.clear();
+      return this.startTurn();
+    }
+    if (m.parent_tool_use_id) return false;
+    if (m.type === "assistant") {
+      const started = this.startTurn();
+      this.ingestToolUses(m);
+      return started;
+    }
+    if (m.type === "user") {
+      this.ingestToolResults(m);
+      return false;
+    }
+    if (m.type === "stream_event")
+      return asRecord2(m.event)?.type === "message_start" && this.startTurn();
+    return false;
+  }
+  startTurn() {
+    if (!this.afterResult) return false;
+    this.afterResult = false;
+    return true;
+  }
+  ingestSystem(m) {
+    const id = String(m.task_id ?? "");
+    switch (m.subtype) {
+      case "background_tasks_changed":
+        this.tasks.clear();
+        for (const entry of asArray(m.tasks)) {
+          const task = asRecord2(entry);
+          if (task) this.addTask(task);
+        }
+        return false;
+      case "task_started":
+        if (m.is_backgrounded === true && !m.owned_by_subagent) this.addTask(m);
+        return false;
+      case "task_notification":
+        this.tasks.delete(id);
+        return false;
+      case "task_updated":
+        if (DONE_STATUSES.has(String(asRecord2(m.patch)?.status)))
+          this.tasks.delete(id);
+        return false;
+      case "init":
+        return this.startTurn();
+      default:
+        return false;
+    }
+  }
+  addTask(task) {
+    const id = String(task.task_id ?? "");
+    if (!id) return;
+    this.seenBackgroundWork = true;
+    this.tasks.set(id, {
+      id,
+      type: String(task.task_type ?? "task"),
+      description: String(task.description ?? "")
+    });
+  }
+  ingestToolUses(m) {
+    for (const entry of asArray(asRecord2(m.message)?.content)) {
+      const block = asRecord2(entry);
+      if (block?.type !== "tool_use") continue;
+      const name = String(block.name ?? "");
+      const input = asRecord2(block.input) ?? {};
+      if (name === "CronDelete" || name === "ScheduleWakeup" && input.stop === true) {
+        this.wakeups.clear();
+        continue;
+      }
+      if (!SCHEDULE_TOOLS.has(name)) continue;
+      const id = String(block.id ?? "");
+      if (!id) continue;
+      this.pendingWakeups.set(id, {
+        id,
+        type: "scheduled_wakeup",
+        description: String(input.prompt ?? input.cron ?? name)
+      });
+    }
+  }
+  ingestToolResults(m) {
+    for (const entry of asArray(asRecord2(m.message)?.content)) {
+      const block = asRecord2(entry);
+      if (block?.type !== "tool_result") continue;
+      const id = String(block.tool_use_id ?? "");
+      const pending = this.pendingWakeups.get(id);
+      if (!pending) continue;
+      this.pendingWakeups.delete(id);
+      if (block.is_error) continue;
+      this.seenBackgroundWork = true;
+      this.wakeups.set(id, pending);
+    }
+  }
+};
+var MAX_TIMER_MS = 2 ** 31 - 1;
+var STOP_TASKS_TIMEOUT_MS = 5e3;
+function withTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+var BackgroundWait = class {
+  constructor(graceMs, ceilingMs) {
+    this.graceMs = graceMs;
+    this.expired = new Promise((resolve) => {
+      this.expire = resolve;
+    });
+    if (Number.isFinite(ceilingMs)) {
+      this.ceiling = setTimeout(() => this.expire("ceiling"), Math.min(ceilingMs, MAX_TIMER_MS));
+    }
+  }
+  graceMs;
+  expired;
+  expire;
+  grace;
+  ceiling;
+  startedAt = Date.now();
+  /** Arm the grace timer while nothing is live; disarm it once a task appears. */
+  setIdle(idle) {
+    if (!idle) {
+      clearTimeout(this.grace);
+      this.grace = void 0;
+      return;
+    }
+    this.grace ??= setTimeout(() => this.expire("grace"), this.graceMs);
+  }
+  elapsedMs() {
+    return Date.now() - this.startedAt;
+  }
+  clear() {
+    clearTimeout(this.grace);
+    clearTimeout(this.ceiling);
+  }
+};
+
 // src/agents/providers/claude-code.ts
-var DAEMON_PROTOCOL_VERSION = "4";
+var DAEMON_PROTOCOL_VERSION = "5";
 var DAEMON_PORT = 43180;
 var DAEMON_PATH = "/tmp/agentbox/claude-code/daemon.mjs";
 var DAEMON_LOG_PATH = "/tmp/agentbox/claude-code/daemon.log";
@@ -2091,6 +2286,29 @@ async function handleStart(req, res, runId) {
     opts.pathToClaudeCodeExecutable,
   );
 
+  let queryHandle;
+  let clientGone = false;
+  // This run's own teardown. The liveRuns entry is only removed when it is
+  // still ours: hosts reuse a runId across retry attempts, and a successor
+  // registered while our CLI winds down must not be evicted by our exit.
+  const releaseRun = () => {
+    clearInterval(heartbeat);
+    clearPermissions();
+    if (liveRuns.get(runId)?.query === queryHandle) liveRuns.delete(runId);
+    promptStream.end();
+  };
+  // Host gone (settled, cancelled or crashed) \u2192 end the prompt so the CLI
+  // winds down instead of living on with its background work. Detected on
+  // the response: \`req\` emits "close" as soon as its body is consumed (Node
+  // >= 16), long before any disconnect, while the response only closes
+  // early when the socket dies before the stream finished.
+  res.on("close", () => {
+    if (res.writableFinished) return;
+    clientGone = true;
+    releaseRun();
+    queryHandle?.interrupt().catch(() => {});
+  });
+
   // Resume-if-exists gate. \`claude --resume <id>\` errors hard with "No
   // conversation found with session ID" when the local session jsonl is
   // missing \u2014 most often because a prior post-task snapshot failed and the
@@ -2121,7 +2339,8 @@ async function handleStart(req, res, runId) {
     }
   }
 
-  let queryHandle;
+  // Nobody left to stream to: do not start a CLI for it.
+  if (clientGone) { res.end(); return; }
   try {
     queryHandle = query({
       prompt: promptStream,
@@ -2144,28 +2363,19 @@ async function handleStart(req, res, runId) {
 
   liveRuns.set(runId, { query: queryHandle, prompt: promptStream, permissions });
 
-  // Client disconnected (e.g. host process killed) \u2192 tear down.
-  req.on("close", () => {
-    clearInterval(heartbeat);
-    clearPermissions();
-    if (!liveRuns.has(runId)) return;
-    liveRuns.delete(runId);
-    promptStream.end();
-    queryHandle.interrupt().catch(() => {});
-  });
-
+  // Forward every SDKMessage, not just up to the first result: in
+  // streaming-input mode the CLI keeps running after a turn ends and
+  // re-prompts the model when background work finishes. The host decides
+  // when the run is over and disconnects (res "close" above), which ends
+  // the prompt and lets the CLI wind down.
   try {
     for await (const message of queryHandle) {
       res.write(JSON.stringify(message) + "\\n");
-      if (message.type === "result") break;
     }
   } catch (e) {
     res.write(JSON.stringify({ _error: String(e?.message ?? e) }) + "\\n");
   } finally {
-    clearInterval(heartbeat);
-    clearPermissions();
-    liveRuns.delete(runId);
-    promptStream.end();
+    releaseRun();
     res.end();
   }
 }
@@ -2555,6 +2765,7 @@ var ClaudeCodeAgentAdapter = class {
       // user inside our images.
       IS_SANDBOX: "1"
     };
+    applyCliBackgroundWaitCeiling(env);
     const customHeaders = request.options.customHeaders;
     if (customHeaders && Object.keys(customHeaders).length > 0) {
       const serialized = Object.entries(customHeaders).map(([name, value]) => `${name}: ${value}`).join("\n");
@@ -2604,17 +2815,23 @@ ${serialized}` : serialized;
       }
     };
     const fetchAbort = new AbortController();
+    const runUrl = `${baseUrl}/runs/${encodeURIComponent(request.runId)}`;
     const cleanup = async () => {
       try {
-        await fetch(
-          `${baseUrl}/runs/${encodeURIComponent(request.runId)}/abort`,
-          { method: "POST", headers: authHeaders }
-        );
+        await fetch(`${runUrl}/abort`, { method: "POST", headers: authHeaders });
+      } catch {
+      }
+      try {
+        await fetch(runUrl, { method: "DELETE", headers: authHeaders, signal: AbortSignal.timeout(3e3) });
       } catch {
       }
       fetchAbort.abort();
     };
-    sink.setAbort(cleanup);
+    let cancelled = false;
+    sink.setAbort(async () => {
+      cancelled = true;
+      await cleanup();
+    });
     sink.onMessage(async (content) => {
       const parts = await validateProviderUserInput(request.provider, content);
       const mapped = mapToClaudeUserContent(parts);
@@ -2680,7 +2897,7 @@ ${serialized}` : serialized;
         if (!reply.ok) throw new Error(`Claude permission response failed: ${reply.status}`);
       }
     };
-    await consumeClaudeMessages(request, sink, permissionMessages(), executeStartedAt, cleanup);
+    await consumeClaudeMessages(request, sink, permissionMessages(), executeStartedAt, cleanup, () => cancelled);
     return async () => void 0;
   }
   /**
@@ -2741,24 +2958,66 @@ ${serialized}` : serialized;
     }
   }
 };
-async function consumeClaudeMessages(request, sink, messages, executeStartedAt, cleanup, wasCancelled = () => false) {
+async function consumeClaudeMessages(request, sink, messages, executeStartedAt, cleanup, wasCancelled = () => false, wait = {}) {
   let accumulatedText = "";
   let streamedThinkingChars = 0;
-  let pendingMessages = 1;
   let sawResult = false;
   let firstStreamEventLogged = false;
   let firstTextDeltaLogged = false;
   let lastTerminalReason;
   let lastIsError = false;
   const rawPayloads = [];
+  const tracker = new BackgroundTaskTracker();
+  const timeoutMs = resolveBackgroundTaskTimeoutMs(request.options.backgroundTaskTimeoutMs);
+  const graceMs = wait.graceMs ?? BACKGROUND_TASK_GRACE_MS;
+  let pendingWait;
+  let waitedMs = 0;
+  let expiry;
+  let lastTasksKey = JSON.stringify({ tasks: [], waiting: false });
+  const emitTasks = (tasks, waiting) => {
+    const key = JSON.stringify({ tasks, waiting });
+    if (key === lastTasksKey) return;
+    lastTasksKey = key;
+    sink.emitEvent(createNormalizedEvent("background.tasks", { provider: request.provider, runId: request.runId }, { tasks, waiting }));
+  };
+  const isAborted = () => wasCancelled() || lastTerminalReason === "aborted_streaming" || lastTerminalReason === "aborted_tools";
+  const endWait = () => {
+    if (!pendingWait) return;
+    waitedMs += pendingWait.elapsedMs();
+    pendingWait.clear();
+    pendingWait = void 0;
+  };
+  const settleOnFailure = (error) => {
+    if (!pendingWait || !sawResult || lastIsError) return false;
+    debugClaude("\u2605 transport failed during background wait; settling on the last result: %o", error);
+    expiry = "transport";
+    return true;
+  };
+  const iterator = messages[Symbol.asyncIterator]();
   try {
-    for await (const item of messages) {
+    for (let next = iterator.next(); ; next = iterator.next()) {
+      let step;
+      try {
+        step = pendingWait ? await Promise.race([
+          next.then((result) => ({ result })),
+          pendingWait.expired.then((reason) => ({ reason }))
+        ]) : { result: await next };
+      } catch (error) {
+        if (!settleOnFailure(error)) throw error;
+        break;
+      }
+      if ("reason" in step) {
+        expiry = step.reason;
+        break;
+      }
+      if (step.result.done) break;
+      const item = step.result.value;
       if (item && typeof item === "object") {
         const ctrl = item;
         if ("_error" in ctrl) {
-          throw new Error(
-            String(item._error ?? "daemon error")
-          );
+          const error = new Error(String(ctrl._error ?? "daemon error"));
+          if (!settleOnFailure(error)) throw error;
+          break;
         }
         if ("_notice" in ctrl) {
           debugClaude("daemon notice: %o", ctrl);
@@ -2775,6 +3034,12 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
       const message = item;
       rawPayloads.push(message);
       sink.emitRaw(toRawEvent(request.runId, message, message.type));
+      if (tracker.ingest(message) && pendingWait) {
+        debugClaude("\u2605 follow-up turn started; background wait over (%dms since execute start)", Date.now() - executeStartedAt);
+        endWait();
+      }
+      emitTasks(tracker.liveTasks(), pendingWait !== void 0);
+      pendingWait?.setIdle(tracker.liveTasks().length === 0);
       if (message.type === "system") {
         const sub = message.subtype;
         if (sub === "init") {
@@ -2891,15 +3156,33 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
         if (resultText && resultText !== accumulatedText) {
           accumulatedText = resultText;
         }
-        pendingMessages--;
-        if (pendingMessages <= 0) break;
+        const live = tracker.liveTasks();
+        if (timeoutMs === 0 || !tracker.hasSeenBackgroundWork() || isAborted()) break;
+        debugClaude("\u2605 turn ended with %d background task(s); waiting", live.length);
+        endWait();
+        pendingWait = new BackgroundWait(graceMs, Math.max(0, timeoutMs - waitedMs));
+        pendingWait.setIdle(live.length === 0);
+        emitTasks(live, true);
         continue;
       }
     }
+    if (expiry === "ceiling") {
+      const ids = tracker.liveTasks().filter((task) => task.type !== "scheduled_wakeup").map((task) => task.id);
+      debugClaude("\u2605 background wait ceiling (%dms) hit; stopping %d task(s)", timeoutMs, ids.length);
+      if (wait.stopTasks) {
+        await withTimeout(wait.stopTasks(ids), wait.stopTimeoutMs ?? STOP_TASKS_TIMEOUT_MS).catch(() => void 0);
+      }
+    } else if (expiry === "grace") {
+      debugClaude("\u2605 background set emptied with no follow-up turn; settling");
+    }
+    if (pendingWait) {
+      endWait();
+      emitTasks([], false);
+    }
     await cleanup();
     if (!sawResult && !wasCancelled()) throw new Error("Claude Code closed before reporting a result");
     const finalText = accumulatedText;
-    const isCancelled = wasCancelled() || lastTerminalReason === "aborted_streaming" || lastTerminalReason === "aborted_tools";
+    const isCancelled = isAborted();
     const isError = !isCancelled && lastIsError;
     if (isCancelled) {
       debugClaude(
@@ -2941,10 +3224,11 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
       });
     }
   } finally {
+    pendingWait?.clear();
     await cleanup();
   }
 }
-async function executeNativeClaude(request, sink) {
+async function executeNativeClaude(request, sink, wait = {}) {
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
   const claudeDir = claudeConfigDir(request.options);
   const input = await validateProviderUserInput(request.provider, request.run.input);
@@ -2969,6 +3253,7 @@ async function executeNativeClaude(request, sink) {
   const messageId = randomUUID();
   prompt.push({ type: "user", uuid: messageId, message: { role: "user", content: mapToClaudeUserContent(input) }, parent_tool_use_id: null });
   const hostEnv = Object.fromEntries(Object.entries({ ...process.env, ...request.options.env }).filter((entry) => entry[1] !== void 0));
+  applyCliBackgroundWaitCeiling(hostEnv);
   if (request.options.customHeaders) {
     const headers = Object.entries(request.options.customHeaders).map(([name, value]) => `${name}: ${value}`).join("\n");
     hostEnv.ANTHROPIC_CUSTOM_HEADERS = [hostEnv.ANTHROPIC_CUSTOM_HEADERS, headers].filter(Boolean).join("\n");
@@ -3041,10 +3326,17 @@ async function executeNativeClaude(request, sink) {
         }
       }
     } });
-    sink.setRaw({ query: handle, claudeDir, runId: request.runId });
+    const live = handle;
+    sink.setRaw({ query: live, claudeDir, runId: request.runId });
     sink.emitEvent(createNormalizedEvent("run.started", { provider: request.provider, runId: request.runId }));
     sink.emitEvent(createNormalizedEvent("message.started", { provider: request.provider, runId: request.runId }, { messageId }));
-    await consumeClaudeMessages(request, sink, handle, Date.now(), stop, () => cancelled);
+    await consumeClaudeMessages(request, sink, live, Date.now(), stop, () => cancelled, {
+      ...wait,
+      // Native owns the CLI: ask it to stop leftover tasks before closing it.
+      stopTasks: async (ids) => {
+        await Promise.all(ids.map((id) => live.stopTask(id).catch(() => void 0)));
+      }
+    });
   } catch (error) {
     await stop();
     if (cancelled) sink.cancel();
@@ -3350,7 +3642,7 @@ function buildThreadParams(cwd, options, request) {
   return {
     cwd,
     model: request.run.model ?? null,
-    ...options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
+    ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     serviceName: "agentbox",
     // Persist the rollout on disk so follow-up runs can call `thread/resume`.
@@ -3365,7 +3657,7 @@ function buildResumeParams(cwd, options, request) {
     threadId: request.run.resumeSessionId,
     cwd,
     model: request.run.model ?? null,
-    ...options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
+    ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
     // We only need the thread id back; we never read `thread.turns`.
@@ -3381,7 +3673,7 @@ function buildForkParams(cwd, options, request) {
     lastTurnId: request.run.forkAtMessageId ?? null,
     cwd,
     model: request.run.model ?? null,
-    ...options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
+    ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
     excludeTurns: true
@@ -3415,7 +3707,7 @@ function buildCodexTurnStartParams(params) {
   return {
     threadId,
     input: inputItems,
-    ...request.options.configuration === "native" && !request.options.fullAccess ? {} : {
+    ...request.options.provider?.approvalPolicy ? { approvalPolicy: request.options.provider.approvalPolicy } : request.options.configuration === "native" && !request.options.fullAccess ? {} : {
       approvalPolicy: !request.options.fullAccess && isInteractiveApproval(request.options) ? "untrusted" : "never"
     },
     ...sandboxPolicy ? { sandboxPolicy } : {},
@@ -3428,6 +3720,40 @@ function buildCodexTurnStartParams(params) {
     outputSchema: null
   };
 }
+var BACKGROUND_OUTPUT_TAIL_CHARS = 4e3;
+function buildCodexBackgroundFollowUp(items) {
+  const reports = items.map((item) => {
+    const tail = (item.aggregatedOutput ?? "").slice(-BACKGROUND_OUTPUT_TAIL_CHARS).trimEnd();
+    const duration = item.durationMs === void 0 ? "an unknown time" : `${Math.round(item.durationMs / 1e3)}s`;
+    return `\`${item.command}\` exited with code ${item.exitCode ?? "unknown"} after ${duration}.
+Output (last ${BACKGROUND_OUTPUT_TAIL_CHARS} chars):
+\`\`\`
+${tail || "(no output)"}
+\`\`\`
+`;
+  });
+  return `Background command finished while you were idle.
+
+${reports.join("")}
+Continue from here: verify the outcome and finish the task. Do not restart the command.`;
+}
+var CODEX_CANCEL_TURN_TEXT = "Run cancelled by the host.";
+async function terminateBackgroundTerminals(client, threadId) {
+  await withTimeout((async () => {
+    try {
+      const listed = await client.request(
+        "thread/backgroundTerminals/list",
+        { threadId }
+      );
+      for (const terminal of listed?.data ?? []) {
+        if (typeof terminal?.processId !== "string") continue;
+        await client.request("thread/backgroundTerminals/terminate", { threadId, processId: terminal.processId });
+      }
+    } catch (error) {
+      debugCodex("background terminal termination stopped early: %o", error);
+    }
+  })(), STOP_TASKS_TIMEOUT_MS);
+}
 function toRawEvent2(runId, payload, type) {
   return {
     provider: AgentProvider.Codex,
@@ -3584,6 +3910,42 @@ function createCodexPermissionEvent(request, notification, fileChanges) {
   }
   return null;
 }
+var CODEX_ELICITATION_METHOD = "mcpServer/elicitation/request";
+function createCodexElicitationPermissionEvent(request, notification) {
+  if (notification.method !== CODEX_ELICITATION_METHOD || notification.id === void 0) {
+    return null;
+  }
+  const params = notification.params ?? {};
+  const meta = params._meta ?? {};
+  if (meta.codex_approval_kind !== "mcp_tool_call") {
+    return null;
+  }
+  const raw = toRawEvent2(request.runId, notification, notification.method);
+  const toolName = typeof meta.tool_name === "string" ? meta.tool_name : void 0;
+  const server = typeof params.serverName === "string" ? params.serverName : void 0;
+  const persist = Array.isArray(meta.persist) ? meta.persist : [];
+  return createNormalizedEvent(
+    "permission.requested",
+    { provider: request.provider, runId: request.runId, raw },
+    {
+      requestId: String(notification.id),
+      kind: "tool",
+      toolName: toolName ?? server,
+      title: "Approve tool call",
+      message: typeof params.message === "string" && params.message.trim() ? params.message : `Codex wants to call ${toolName ?? "an MCP tool"}${server ? ` on ${server}` : ""}.`,
+      input: { server, tool: toolName, arguments: meta.tool_params, ...params },
+      canRemember: persist.includes("session")
+    }
+  );
+}
+function toCodexElicitationResult(notification, response) {
+  if (response.decision === "deny") {
+    return { action: "decline", content: null };
+  }
+  const meta = notification.params?._meta ?? {};
+  const persist = Array.isArray(meta.persist) ? meta.persist : [];
+  return response.remember && persist.includes("session") ? { action: "accept", content: null, _meta: { persist: "session" } } : { action: "accept", content: null };
+}
 function toCodexApprovalDecision(notification, response) {
   const params = notification.params ?? {};
   const availableDecisions = Array.isArray(params.availableDecisions) ? params.availableDecisions : [];
@@ -4201,10 +4563,92 @@ var CodexAgentAdapter = class {
     const pendingFileChanges = /* @__PURE__ */ new Map();
     const fileItemKey = (params, itemId) => typeof params?.threadId === "string" && typeof params.turnId === "string" && typeof itemId === "string" ? `${params.threadId}:${params.turnId}:${itemId}` : void 0;
     let streamedText = "";
+    const timeoutMs = resolveBackgroundTaskTimeoutMs(request.options.backgroundTaskTimeoutMs);
+    const isRootThread = (params) => !params?.threadId || params.threadId === rootThreadId;
+    const inFlight = /* @__PURE__ */ new Map();
+    const finished = [];
+    let pendingWait;
+    let waitedMs = 0;
+    let followUpSent = false;
+    let turnMessageText = "";
+    let lastTurn;
+    let lastTasksKey = JSON.stringify({ tasks: [], waiting: false });
+    const liveTasks = () => [...inFlight.values()].filter((item) => item.outlived).map((item) => ({ id: item.id, type: "command", description: item.command }));
+    const emitTasks = (tasks, waiting) => {
+      const key = JSON.stringify({ tasks, waiting });
+      if (key === lastTasksKey) return;
+      lastTasksKey = key;
+      sink.emitEvent(createNormalizedEvent("background.tasks", { provider: request.provider, runId: request.runId }, { tasks, waiting }));
+    };
+    const endWait = () => {
+      if (!pendingWait) return;
+      waitedMs += pendingWait.elapsedMs();
+      pendingWait.clear();
+      pendingWait = void 0;
+      followUpSent = false;
+    };
+    const sendBackgroundFollowUp = async () => {
+      if (!rootThreadId || !pendingWait || followUpSent || finished.length === 0 || abortInvoked) return;
+      if (timeoutMs - waitedMs - pendingWait.elapsedMs() <= 0) return;
+      followUpSent = true;
+      const text2 = buildCodexBackgroundFollowUp(finished.splice(0));
+      try {
+        const response = await client.request(
+          "turn/start",
+          buildCodexTurnStartParams({
+            threadId: rootThreadId,
+            inputItems: [{ type: "text", text: text2, text_elements: [] }],
+            request
+          })
+        );
+        endWait();
+        sink.emitEvent(createNormalizedEvent("message.injected", { provider: request.provider, runId: request.runId }, {
+          content: text2,
+          ...typeof response?.turn?.id === "string" ? { messageId: response.turn.id } : {}
+        }));
+      } catch (error) {
+        debugCodex("background follow-up turn/start failed: %o", error);
+      }
+    };
     const completion = new Promise((resolve, reject) => {
+      const settle = () => {
+        endWait();
+        emitTasks([], false);
+        sink.emitEvent(createNormalizedEvent("run.completed", { provider: request.provider, runId: request.runId }, { text: lastTurn?.messageText || void 0 }));
+        resolve({ text: lastTurn?.text ?? streamedText, turnId, threadId: rootThreadId, interrupted: false });
+      };
+      const settleOnFailure = (error) => {
+        if (!pendingWait || !lastTurn || abortInvoked) return false;
+        debugCodex("\u2605 transport failed during background wait; settling on the last turn: %o", error);
+        settle();
+        return true;
+      };
       void (async () => {
         let firstClientMessageLogged = false;
-        for await (const message of client.messages()) {
+        const iterator = client.messages()[Symbol.asyncIterator]();
+        for (let next = iterator.next(); ; next = iterator.next()) {
+          let step;
+          try {
+            step = pendingWait ? await Promise.race([
+              next.then((result) => ({ result })),
+              pendingWait.expired.then((reason) => ({ reason }))
+            ]) : { result: await next };
+          } catch (error) {
+            if (settleOnFailure(error)) return;
+            throw error;
+          }
+          if ("reason" in step) {
+            if (!abortInvoked) {
+              debugCodex("\u2605 background wait over (%s) with %d command(s) in flight", step.reason, inFlight.size);
+              if (step.reason === "ceiling" && rootThreadId) await terminateBackgroundTerminals(client, rootThreadId);
+              settle();
+              return;
+            }
+            endWait();
+            step = { result: await next };
+          }
+          if (step.result.done) break;
+          const message = step.result.value;
           if (!firstClientMessageLogged) {
             firstClientMessageLogged = true;
             debugCodex(
@@ -4260,36 +4704,96 @@ var CodexAgentAdapter = class {
             if (approvalKey) pendingFileChanges.delete(approvalKey);
             continue;
           }
+          const elicitation = createCodexElicitationPermissionEvent(request, message);
+          if (elicitation && message.id !== void 0) {
+            const response = interactiveApproval ? await sink.requestPermission(elicitation) : { requestId: elicitation.requestId, decision: "allow" };
+            await client.respond(message.id, toCodexElicitationResult(message, response));
+            continue;
+          }
+          if (message.id !== void 0) {
+            debugCodex("unsupported server request %s; declining", message.method);
+            await (message.method === CODEX_ELICITATION_METHOD ? client.respond(message.id, { action: "cancel", content: null }) : client.respondError(message.id, {
+              code: -32601,
+              message: `Unsupported request ${message.method}`
+            }));
+            continue;
+          }
           if (message.method === "item/completed") {
             const item2 = message.params?.item;
             if (item2?.type === "plan" && typeof item2.text === "string") {
               sink.emitEvent(createNormalizedEvent("plan.completed", { provider: request.provider, runId: request.runId }, { text: item2.text }));
             }
           }
+          const turn = message.params?.turn;
+          const rootTurnCompleted = message.method === "turn/completed" && isRootThread(message.params);
+          const waitAfterTurn = rootTurnCompleted && pendingTurns <= 1 && timeoutMs !== 0 && !abortInvoked && turn?.status === "completed" && (inFlight.size > 0 || finished.length > 0);
           for (const event of toNormalizedCodexEvents(request.runId, message)) {
+            if (event.type === "run.completed" && (waitAfterTurn || turn?.status === "interrupted")) continue;
             sink.emitEvent(event);
             if (event.type === "text.delta") {
               streamedText += event.delta;
+            } else if (event.type === "message.completed" && event.text) {
+              turnMessageText = event.text;
             }
           }
           if (message.method === "thread/started" && !rootThreadId) {
             rootThreadId = message.params?.thread?.id ?? rootThreadId;
           }
           if (message.method === "turn/started") {
-            turnId = message.params?.turn?.id ?? turnId;
+            turnId = turn?.id ?? turnId;
+            if (isRootThread(message.params)) {
+              streamedText = "";
+              turnMessageText = "";
+              if (pendingWait) debugCodex("\u2605 follow-up turn started; background wait over");
+              endWait();
+              emitTasks(liveTasks(), false);
+            }
           }
-          if (message.method === "turn/completed" && (!message.params?.threadId || message.params.threadId === rootThreadId)) {
+          if (item?.type === "commandExecution" && typeof item.id === "string" && isRootThread(message.params)) {
+            if (message.method === "item/started") {
+              inFlight.set(item.id, {
+                id: item.id,
+                command: String(item.command ?? ""),
+                processId: typeof item.processId === "string" ? item.processId : void 0,
+                outlived: false
+              });
+            } else if (message.method === "item/completed") {
+              const tracked = inFlight.get(item.id);
+              inFlight.delete(item.id);
+              if (tracked?.outlived && pendingWait) {
+                finished.push({
+                  ...tracked,
+                  aggregatedOutput: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : void 0,
+                  exitCode: typeof item.exitCode === "number" ? item.exitCode : void 0,
+                  durationMs: typeof item.durationMs === "number" ? item.durationMs : void 0
+                });
+              }
+              emitTasks(liveTasks(), pendingWait !== void 0);
+              pendingWait?.setIdle(inFlight.size === 0);
+              if (pendingWait && inFlight.size === 0) await sendBackgroundFollowUp();
+            }
+          }
+          if (rootTurnCompleted) {
             pendingTurns--;
             if (pendingTurns <= 0) {
-              const turn = message.params?.turn;
-              const interrupted = turn?.status === "interrupted";
-              resolve({
-                text: streamedText,
-                turnId,
-                threadId: rootThreadId,
-                interrupted
-              });
-              return;
+              const previousText = lastTurn?.text;
+              lastTurn = { text: streamedText, messageText: turnMessageText };
+              if (!waitAfterTurn) {
+                resolve({
+                  text: streamedText || previousText,
+                  turnId,
+                  threadId: rootThreadId,
+                  interrupted: turn?.status === "interrupted"
+                });
+                return;
+              }
+              for (const tracked of inFlight.values()) tracked.outlived = true;
+              debugCodex("\u2605 turn ended with %d command(s) in flight; waiting", inFlight.size);
+              endWait();
+              pendingWait = new BackgroundWait(BACKGROUND_TASK_GRACE_MS, Math.max(0, timeoutMs - waitedMs));
+              pendingWait.setIdle(inFlight.size === 0);
+              emitTasks(liveTasks(), true);
+              if (inFlight.size === 0) await sendBackgroundFollowUp();
             }
           }
           if (message.method === "error" && !shouldIgnoreCodexError(message)) {
@@ -4297,6 +4801,7 @@ var CodexAgentAdapter = class {
             return;
           }
         }
+        if (settleOnFailure(new Error("Codex transport closed."))) return;
         reject(new Error("Codex transport closed before run completed."));
       })().catch(reject);
     });
@@ -4367,6 +4872,8 @@ var CodexAgentAdapter = class {
       } catch (err) {
         completionError = err;
       }
+      endWait();
+      emitTasks([], false);
       if (completionError !== void 0) {
         if (abortInvoked) {
           debugCodex(
@@ -4374,7 +4881,7 @@ var CodexAgentAdapter = class {
             Date.now() - executeStartedAt
           );
           sink.cancel({
-            text: streamedText || void 0,
+            text: streamedText || lastTurn?.text || void 0,
             costData: extractCodexCostData(rawPayloads)
           });
         } else {
@@ -4399,6 +4906,7 @@ var CodexAgentAdapter = class {
         }
       }
     } finally {
+      pendingWait?.clear();
       await runtime.cleanup().catch(() => void 0);
     }
     return async () => void 0;
@@ -4411,36 +4919,51 @@ var CodexAgentAdapter = class {
    * driven by the normalized `message.started` event whose
    * `messageId` IS the codex turnId).
    *
-   * If `sessionId` or `turnId` is missing the call is a no-op.
+   * When that interrupt is rejected — the thread is idle in a background
+   * wait, or the turn id is stale or missing — a turn is started only to be
+   * interrupted, so the originating run still observes an interrupted turn
+   * and cancels; the model's leftover processes are then terminated.
+   * Without `sessionId` the call is a no-op.
    */
   async attachAbort(request) {
     const threadId = request.sessionId;
-    const turnId = request.turnId;
-    if (!threadId || !turnId) {
-      debugCodex(
-        "attachAbort runId=%s skipped: threadId=%s turnId=%s",
-        request.runId,
-        threadId,
-        turnId
-      );
+    if (!threadId) {
+      debugCodex("attachAbort runId=%s skipped: no threadId", request.runId);
       return;
     }
     await withCodexAppServer(request, async (client) => {
-      await Promise.race([
-        client.request("turn/interrupt", { threadId, turnId }),
+      const bounded = (what, promise) => Promise.race([
+        promise,
         new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("codex turn/interrupt timed out")),
-            3e3
-          )
+          (_, reject) => setTimeout(() => reject(new Error(`codex ${what} timed out`)), 3e3)
         )
-      ]).catch((error) => {
-        debugCodex(
-          "attachAbort runId=%s turn/interrupt failed: %o",
-          request.runId,
-          error
+      ]);
+      const interrupt = (turnId) => bounded("turn/interrupt", client.request("turn/interrupt", { threadId, turnId }));
+      if (request.turnId) {
+        try {
+          await interrupt(request.turnId);
+          return;
+        } catch (error) {
+          debugCodex("attachAbort runId=%s turn/interrupt failed: %o", request.runId, error);
+        }
+      }
+      try {
+        const response = await bounded(
+          "turn/start",
+          client.request("turn/start", {
+            threadId,
+            input: [{ type: "text", text: CODEX_CANCEL_TURN_TEXT, text_elements: [] }],
+            approvalPolicy: "never",
+            model: null,
+            effort: null,
+            outputSchema: null
+          })
         );
-      });
+        if (typeof response?.turn?.id === "string") await interrupt(response.turn.id);
+      } catch (error) {
+        debugCodex("attachAbort runId=%s cancel turn failed: %o", request.runId, error);
+      }
+      await terminateBackgroundTerminals(client, threadId);
     });
   }
   /**
@@ -4569,6 +5092,9 @@ function toRawEvent3(runId, payload, type) {
     payload
   };
 }
+function injectedTaskResultChild(text2) {
+  return /<task id="?([^"\s>]+)"? state="?(?:completed|error)"?>/.exec(text2)?.[1];
+}
 function toOpenCodeModel(model) {
   if (!model) {
     return void 0;
@@ -5094,35 +5620,149 @@ var OpenCodeAgentAdapter = class {
       resolveSessionTerminal = resolve;
     });
     let lastSseActivityAt = Date.now();
+    const postAbort = async (id) => {
+      try {
+        await Promise.race([
+          fetchJson(`${runtime.baseUrl}/session/${id}/abort`, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              ...runtime.previewHeaders
+            }
+          }),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error("opencode POST /session/abort timed out")),
+              3e3
+            )
+          )
+        ]);
+      } catch {
+      }
+    };
     let userAbortRequested = false;
     sink.setAbort(async () => {
       userAbortRequested = true;
       const sessionIdAtAbort = capturedSessionId;
-      if (sessionIdAtAbort) {
-        try {
-          await Promise.race([
-            fetchJson(
-              `${runtime.baseUrl}/session/${sessionIdAtAbort}/abort`,
-              {
-                method: "POST",
-                headers: {
-                  "content-type": "application/json",
-                  ...runtime.previewHeaders
-                }
-              }
-            ),
-            new Promise(
-              (_, reject) => setTimeout(
-                () => reject(new Error("opencode POST /session/abort timed out")),
-                3e3
-              )
-            )
-          ]);
-        } catch {
-        }
-      }
+      if (sessionIdAtAbort) await postAbort(sessionIdAtAbort);
       resolveSessionTerminal();
     });
+    const backgroundTimeoutMs = resolveBackgroundTaskTimeoutMs(
+      request.options.backgroundTaskTimeoutMs
+    );
+    const trackChildren = backgroundTimeoutMs !== 0;
+    const children = /* @__PURE__ */ new Map();
+    const liveChildren = () => [...children.values()].filter((child) => child.live).map((child) => ({
+      id: child.id,
+      type: "subagent",
+      description: child.title
+    }));
+    const shouldWait = () => [...children.values()].some((child) => child.background) && liveChildren().length > 0;
+    let pendingWait;
+    let waitedMs = 0;
+    let expiry;
+    let sawParentIdle = false;
+    let lastTasksKey = JSON.stringify({ tasks: [], waiting: false });
+    const emitTasks = (tasks, waiting) => {
+      const key = JSON.stringify({ tasks, waiting });
+      if (key === lastTasksKey) return;
+      lastTasksKey = key;
+      sink.emitEvent(
+        createNormalizedEvent(
+          "background.tasks",
+          { provider: request.provider, runId: request.runId },
+          { tasks, waiting }
+        )
+      );
+    };
+    const endWait = () => {
+      if (!pendingWait) return;
+      waitedMs += pendingWait.elapsedMs();
+      pendingWait.clear();
+      pendingWait = void 0;
+    };
+    const onChildrenChanged = () => {
+      if (!pendingWait) return;
+      const live = liveChildren();
+      emitTasks(live, true);
+      pendingWait.setIdle(live.length === 0);
+    };
+    const registerChild = (id, title, background = false) => {
+      const known = children.get(id);
+      if (known) {
+        known.background ||= background;
+        if (title && title !== known.title) {
+          known.title = title;
+          onChildrenChanged();
+        }
+        return;
+      }
+      children.set(id, { id, title: title ?? "", live: true, background });
+      onChildrenChanged();
+    };
+    const setChildLive = (id, live) => {
+      const child = children.get(id);
+      if (!child || child.live === live) return;
+      child.live = live;
+      onChildrenChanged();
+    };
+    const reconcileChildren = async () => {
+      const live = [...children.values()].filter((child) => child.live);
+      if (live.length === 0) return;
+      const statuses = await withTimeout(
+        fetchJson(
+          `${runtime.baseUrl}/session/status`,
+          { headers: runtime.previewHeaders }
+        ).catch(() => void 0),
+        3e3
+      );
+      if (!statuses || typeof statuses !== "object") return;
+      for (const child of live) {
+        const status = statuses[child.id];
+        if (!status || status.type === "idle") setChildLive(child.id, false);
+      }
+    };
+    const onParentIdle = async () => {
+      sawParentIdle = true;
+      if (pendingWait || sessionIdleFromSse) return;
+      const tracking = trackChildren && !userAbortRequested;
+      if (tracking && shouldWait()) await reconcileChildren();
+      if (!tracking || !shouldWait()) {
+        sessionIdleFromSse = true;
+        resolveSessionTerminal();
+        return;
+      }
+      const live = liveChildren();
+      debugOpencode(
+        "\u2605 parent idle with %d live subagent(s); waiting",
+        live.length
+      );
+      const wait = new BackgroundWait(
+        BACKGROUND_TASK_GRACE_MS,
+        Math.max(0, backgroundTimeoutMs - waitedMs)
+      );
+      pendingWait = wait;
+      void wait.expired.then((reason) => {
+        if (pendingWait !== wait) return;
+        expiry = reason;
+        resolveSessionTerminal();
+      });
+      emitTasks(live, true);
+    };
+    const onParentBusy = () => {
+      if (!pendingWait) return;
+      debugOpencode(
+        "\u2605 parent resumed after %dms of background wait",
+        pendingWait.elapsedMs()
+      );
+      endWait();
+      emitTasks(liveChildren(), false);
+    };
+    const onInjectedResult = (childId) => {
+      if (!children.has(childId)) return;
+      setChildLive(childId, false);
+      onParentBusy();
+    };
     try {
       const interactiveApproval = !request.options.fullAccess && isInteractiveApproval(request.options);
       let forkedSession = null;
@@ -5225,6 +5865,12 @@ var OpenCodeAgentAdapter = class {
               const info = properties?.info;
               if (info && typeof info.id === "string" && typeof info.parentID === "string" && runSessionIds.has(info.parentID)) {
                 runSessionIds.add(info.id);
+                if (trackChildren && info.parentID === sessionId) {
+                  registerChild(
+                    info.id,
+                    typeof info.title === "string" ? info.title : void 0
+                  );
+                }
               }
             }
             if (eventType === "message.updated") {
@@ -5333,28 +5979,35 @@ var OpenCodeAgentAdapter = class {
                     const errMsg = typeof errData?.data?.message === "string" ? errData.data.message : typeof errData?.message === "string" ? errData.message : "OpenCode session error";
                     sessionErrorFromSse = new Error(errMsg);
                   }
+                  resolveSessionTerminal();
                 } else {
-                  sessionIdleFromSse = true;
+                  await onParentIdle();
                 }
                 debugOpencode(
                   "\u2605 %s for session=%s",
                   payloadRecord.type,
                   sessionId
                 );
-                resolveSessionTerminal();
+              } else if (trackChildren && payloadRecord.type === "session.idle") {
+                setChildLive(eventSessionId, false);
               }
             }
             if (payloadRecord?.type === "session.status") {
               const properties = payloadRecord.properties;
               const status = properties?.status;
               const eventSessionId = typeof properties?.sessionID === "string" ? properties.sessionID : void 0;
-              if ((!eventSessionId || eventSessionId === sessionId) && status?.type === "idle") {
-                sessionIdleFromSse = true;
-                debugOpencode(
-                  "\u2605 session.status{idle} for session=%s",
-                  sessionId
-                );
-                resolveSessionTerminal();
+              if (!eventSessionId || eventSessionId === sessionId) {
+                if (status?.type === "idle") {
+                  debugOpencode(
+                    "\u2605 session.status{idle} for session=%s",
+                    sessionId
+                  );
+                  await onParentIdle();
+                } else if (status?.type === "busy" || status?.type === "retry") {
+                  onParentBusy();
+                }
+              } else if (trackChildren) {
+                setChildLive(eventSessionId, status?.type !== "idle");
               }
             }
             if (payloadRecord?.type === "message.part.updated") {
@@ -5363,6 +6016,22 @@ var OpenCodeAgentAdapter = class {
               if (part && typeof part.id === "string" && typeof part.type === "string") {
                 partTypeById.set(part.id, part.type);
               }
+              if (trackChildren && part?.type === "tool" && part.tool === "task" && part.sessionID === sessionId) {
+                const state = part.state;
+                const metadata = state?.metadata;
+                const childId = metadata?.sessionId ?? metadata?.jobId;
+                if (metadata?.background === true && typeof childId === "string") {
+                  registerChild(
+                    childId,
+                    typeof state?.title === "string" ? state.title : void 0,
+                    true
+                  );
+                }
+              }
+              if (trackChildren && part?.type === "text" && part.synthetic === true && part.sessionID === sessionId && typeof part.text === "string") {
+                const childId = injectedTaskResultChild(part.text);
+                if (childId) onInjectedResult(childId);
+              }
             }
             if (payloadRecord?.type === "message.part.delta") {
               const properties = payloadRecord.properties;
@@ -5373,6 +6042,9 @@ var OpenCodeAgentAdapter = class {
               if (isForeignSession) {
                 continue;
               }
+              if (eventMessageId !== void 0 && announcedUserMessageIds.has(eventMessageId)) {
+                continue;
+              }
               const delta = typeof properties?.delta === "string" ? properties.delta : "";
               const field = typeof properties?.field === "string" ? properties.field : void 0;
               const partType = eventPartId ? partTypeById.get(eventPartId) : void 0;
@@ -5523,13 +6195,22 @@ var OpenCodeAgentAdapter = class {
       const SSE_POLL_INTERVAL_MS = 5e3;
       lastSseActivityAt = Date.now();
       let sseSilent = false;
-      while (!sessionIdleFromSse && !sessionErrorFromSse && !sessionAbortedFromSse && !userAbortRequested && !dispatchError) {
+      while (!sessionIdleFromSse && !sessionErrorFromSse && !sessionAbortedFromSse && !userAbortRequested && !dispatchError && !expiry) {
         const silence = Date.now() - lastSseActivityAt;
         if (silence > SSE_SILENCE_THRESHOLD_MS) {
+          if (pendingWait && sawParentIdle) {
+            debugOpencode(
+              "SSE went silent (%dms) during background wait; settling",
+              silence
+            );
+            expiry = "transport";
+            break;
+          }
           sseSilent = true;
           debugOpencode("SSE went silent (%dms) \u2014 giving up", silence);
           break;
         }
+        if (pendingWait && liveChildren().length > 0) await reconcileChildren();
         await Promise.race([
           sessionTerminal,
           new Promise(
@@ -5539,6 +6220,16 @@ var OpenCodeAgentAdapter = class {
       }
       sseAbort.abort();
       await sseTask;
+      if (expiry === "ceiling" || (sessionErrorFromSse || dispatchError) && liveChildren().length > 0) {
+        debugOpencode(
+          "\u2605 run over (%s) with %d subagent(s) live; aborting them",
+          expiry ?? "failure",
+          liveChildren().length
+        );
+        await postAbort(sessionId);
+      }
+      endWait();
+      emitTasks([], false);
       if (userAbortRequested || sessionAbortedFromSse) {
         debugOpencode(
           "\u2605 run.cancelled (%dms since execute start)",
@@ -5552,7 +6243,7 @@ var OpenCodeAgentAdapter = class {
         sink.fail(sessionErrorFromSse);
       } else if (dispatchError) {
         sink.fail(dispatchError);
-      } else if (sessionIdleFromSse) {
+      } else if (sessionIdleFromSse || expiry) {
         debugOpencode(
           "\u2605 run.completed (%dms since execute start) chars=%d",
           Date.now() - executeStartedAt,
@@ -5597,6 +6288,7 @@ var OpenCodeAgentAdapter = class {
         sink.fail(new Error("opencode run ended without a terminal signal"));
       }
     } finally {
+      endWait();
       sseAbort.abort();
       if (sseTask) {
         await sseTask.catch(() => void 0);
@@ -5744,6 +6436,7 @@ function prepareAgentOptions(_provider, options) {
     if (!path11.isAbsolute(options.stateDirectory)) throw new Error("stateDirectory must be an absolute path.");
   }
   if (options.sandbox && options.processGroup !== void 0) throw new Error("processGroup is only supported for host execution.");
+  resolveBackgroundTaskTimeoutMs(options.backgroundTaskTimeoutMs);
   if (options.configuration === "native") {
     if (options.sandbox) throw new Error("Native configuration is only supported for host execution.");
     if (options.mcps?.length || options.skills?.length || options.subAgents?.length || options.commands?.length || options.enableRtk) {