@band-app/server 0.37.0 → 0.39.0

package/dist/start-server.mjs

@@ -92313,11 +92313,17 @@ function notify(chatId) {
 }
 function cloneMessage(msg) {
   return {
-    id: msg.id,
-    text: msg.text,
+    ...msg,
     files: msg.files ? msg.files.map((f2) => ({ ...f2 })) : void 0
   };
 }
+function turnOptions(input) {
+  return {
+    ...input.mode !== void 0 && { mode: input.mode },
+    ...input.model !== void 0 && { model: input.model },
+    ...input.codingAgentId !== void 0 && { codingAgentId: input.codingAgentId }
+  };
+}
 function subscribeQueue(listener) {
   queueListeners.add(listener);
   return () => {
@@ -92328,7 +92334,8 @@ function pushQueuedMessage(chatId, input) {
   const message = {
     id: randomUUID(),
     text: input.text,
-    files: input.files && input.files.length > 0 ? input.files.map((f2) => ({ ...f2 })) : void 0
+    files: input.files && input.files.length > 0 ? input.files.map((f2) => ({ ...f2 })) : void 0,
+    ...turnOptions(input)
   };
   const msgs = store.get(chatId);
   if (msgs) {
@@ -92343,11 +92350,17 @@ function setQueuedMessages(chatId, messages) {
   if (messages.length === 0) {
     store.delete(chatId);
   } else {
-    const stored = messages.map((m3) => ({
-      id: m3.id ?? randomUUID(),
-      text: m3.text,
-      files: m3.files && m3.files.length > 0 ? m3.files.map((f2) => ({ ...f2 })) : void 0
-    }));
+    const previous = new Map((store.get(chatId) ?? []).map((m3) => [m3.id, m3]));
+    const stored = messages.map((m3) => {
+      const kept = m3.id !== void 0 ? previous.get(m3.id) : void 0;
+      return {
+        id: m3.id ?? randomUUID(),
+        text: m3.text,
+        files: m3.files && m3.files.length > 0 ? m3.files.map((f2) => ({ ...f2 })) : void 0,
+        ...kept && turnOptions(kept),
+        ...turnOptions(m3)
+      };
+    });
     store.set(chatId, stored);
   }
   notify(chatId);
@@ -92355,6 +92368,13 @@ function setQueuedMessages(chatId, messages) {
 function getQueuedMessages(chatId) {
   return (store.get(chatId) ?? []).map(cloneMessage);
 }
+function hasQueuedMessages(chatId) {
+  return (store.get(chatId)?.length ?? 0) > 0;
+}
+function peekQueuedMessage(chatId) {
+  const first = store.get(chatId)?.[0];
+  return first ? cloneMessage(first) : null;
+}
 function shiftQueuedMessage(chatId) {
   const msgs = store.get(chatId);
   if (!msgs || msgs.length === 0) return null;
@@ -107359,8 +107379,42 @@ var CLIENT_CAPABILITIES = {
   // Claude Code's AskUserQuestion arrives as a form elicitation, and is
   // disabled when the client can't render one.
   elicitation: { form: {} },
-  session: { notices: {} }
-};
+  session: { notices: {} },
+  // JetBrains AIR extension: the Claude adapter reports background work
+  // (background Bash, Monitor, workflows) as `async_task_*` updates only to
+  // a client that lists `asyncTasks`. Band uses them to keep the process
+  // alive while that work runs.
+  _meta: { jetbrains: { air: { version: 1, capabilities: ["asyncTasks"] } } }
+};
+function asAsyncTaskNotification(message) {
+  if (!message || typeof message !== "object") return null;
+  const m3 = message;
+  if (m3.method !== methods.client.session.update) return null;
+  const params = m3.params;
+  const update = params?.update;
+  if (typeof params?.sessionId !== "string" || typeof update?.sessionUpdate !== "string" || !update.sessionUpdate.startsWith("async_task_") || typeof update.asyncTaskId !== "string") {
+    return null;
+  }
+  return params;
+}
+function splitAsyncTasks(readable, onAsyncTask) {
+  return readable.pipeThrough(
+    new TransformStream({
+      transform(message, controller) {
+        const task = asAsyncTaskNotification(message);
+        if (!task) {
+          controller.enqueue(message);
+          return;
+        }
+        try {
+          onAsyncTask(task);
+        } catch (err) {
+          log.warn({ err }, "async task handler threw");
+        }
+      }
+    })
+  );
+}
 function stderrTail() {
   let buf = "";
   return {
@@ -107426,10 +107480,14 @@ var AcpAgentProcess = class _AcpAgentProcess {
     } catch (err) {
       throw new Error(`Could not start ${label}: ${err.message}`);
     }
-    const stream = ndJsonStream2(
+    const wire = ndJsonStream2(
       Writable.toWeb(child.stdin),
       Readable.toWeb(child.stdout)
     );
+    const stream = {
+      writable: wire.writable,
+      readable: splitAsyncTasks(wire.readable, (n) => handlers3.onAsyncTask?.(n))
+    };
     const connection = client({ name: "band" }).onNotification(methods.client.session.update, (ctx) => {
       handlers3.onUpdate(ctx.params);
     }).onRequest(methods.client.session.requestPermission, async (ctx) => ({
@@ -107801,11 +107859,11 @@ function resumeCliInvocation(agentType, sessionId, opts) {
 var CLAUDE_CODE_INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
 function mapClaudeCodeHookStatus(payload) {
   const hookEvent = typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
-  const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "";
+  const toolName2 = typeof payload.tool_name === "string" ? payload.tool_name : "";
   if (hookEvent === "Stop") {
     return "needs_attention";
   }
-  if ((hookEvent === "PreToolUse" || hookEvent === "PermissionRequest") && CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName)) {
+  if ((hookEvent === "PreToolUse" || hookEvent === "PermissionRequest") && CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName2)) {
     return "needs_attention";
   }
   return "working";
@@ -116936,6 +116994,101 @@ var ChatEventQueries = class {
   }
 };
 
+// src/server/services/_utils/agent-pending-work.ts
+var MAX_HOLD_MS = 8 * 60 * 6e4;
+var MONITOR_DEFAULT_TIMEOUT_MS = 5 * 6e4;
+function toolName(update) {
+  const meta2 = update._meta;
+  const name3 = meta2?.claudeCode?.toolName ?? update.name;
+  return typeof name3 === "string" ? name3 : void 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+var PendingWork = class {
+  holds = /* @__PURE__ */ new Map();
+  /** Tool calls an async task was announced for. */
+  taskToolCalls = /* @__PURE__ */ new Set();
+  /** Notes what a `session/update` starts or ends. `inTurn` is whether a
+   *  Band-started turn is running. */
+  observeUpdate(update, inTurn, now = Date.now()) {
+    if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") return;
+    const key2 = `tool:${update.toolCallId}`;
+    if (this.taskToolCalls.has(update.toolCallId)) return;
+    if (update.status === "failed") {
+      this.holds.delete(key2);
+      return;
+    }
+    const held = this.holds.get(key2);
+    if (update.status === "completed") {
+      if (held?.untilCompleted) this.holds.delete(key2);
+      return;
+    }
+    if (held) return;
+    const hold = this.toolHold(update, now);
+    if (hold) {
+      this.set(key2, hold, now);
+      return;
+    }
+    if (!inTurn && update.sessionUpdate === "tool_call") {
+      this.set(key2, { reason: "tool call", until: now + MAX_HOLD_MS, untilCompleted: true }, now);
+    }
+  }
+  /** Notes an AIR async task starting or ending. */
+  observeAsyncTask(update, now = Date.now()) {
+    const key2 = `task:${update.asyncTaskId}`;
+    if (update.sessionUpdate === "async_task_spawned") {
+      if (update.toolCallId) {
+        this.taskToolCalls.add(update.toolCallId);
+        this.holds.delete(`tool:${update.toolCallId}`);
+      }
+      this.set(
+        key2,
+        { reason: `${update.taskType ?? "background"} task`, until: now + MAX_HOLD_MS },
+        now
+      );
+    } else if (update.sessionUpdate === "async_task_state_update" && (update.state === "completed" || update.state === "failed" || update.state === "stopped")) {
+      this.holds.delete(key2);
+      if (update.toolCallId) this.holds.delete(`tool:${update.toolCallId}`);
+    }
+  }
+  /** The holds still in force, dropping the ones that lapsed. */
+  outstanding(now = Date.now()) {
+    for (const [key2, hold] of this.holds) {
+      if (hold.until <= now) this.holds.delete(key2);
+    }
+    return [...this.holds.values()];
+  }
+  clear() {
+    this.holds.clear();
+    this.taskToolCalls.clear();
+  }
+  toolHold(update, now) {
+    const input = update.rawInput;
+    if (!input || typeof input !== "object") return null;
+    switch (toolName(update)) {
+      case "ScheduleWakeup": {
+        const delaySeconds = finiteNumber(input.delaySeconds);
+        return delaySeconds === void 0 ? null : { reason: "scheduled wakeup", until: now + delaySeconds * 1e3 };
+      }
+      case "CronCreate":
+        return { reason: "cron job", until: now + MAX_HOLD_MS };
+      case "Monitor": {
+        const timeout = finiteNumber(input.timeout_ms) ?? MONITOR_DEFAULT_TIMEOUT_MS;
+        return { reason: "monitor", until: now + timeout };
+      }
+      case "Bash":
+      case "PowerShell":
+        return input.run_in_background === true ? { reason: "background command", until: now + MAX_HOLD_MS, untilCompleted: true } : null;
+      default:
+        return null;
+    }
+  }
+  set(key2, hold, now) {
+    this.holds.set(key2, { ...hold, until: Math.min(hold.until, now + MAX_HOLD_MS) });
+  }
+};
+
 // src/server/services/_utils/chat-log-replay.ts
 function textChunk(row) {
   const event = row.event;
@@ -131567,9 +131720,11 @@ var import_react29 = __toESM(require_react(), 1);
 
 // src/dashboard/lib/checks-tab.ts
 var CHECKS_SIDE_TAB = "plugin:github.pull-request";
-function showChecksTab() {
+function showChecksTab(workspaceId2) {
   window.dispatchEvent(
-    new CustomEvent("band:right-sidepanel-set-tab", { detail: { tab: CHECKS_SIDE_TAB } })
+    new CustomEvent("band:right-sidepanel-set-tab", {
+      detail: { tab: CHECKS_SIDE_TAB, workspaceId: workspaceId2 }
+    })
   );
   window.dispatchEvent(new CustomEvent("band:show-right-panel"));
 }
@@ -131895,9 +132050,23 @@ function WorkspaceLabel({
   const nameClass = tone === "switcher" ? `text-foreground ${isActive ? "font-semibold" : "font-medium"}` : isActive ? "font-bold text-foreground" : "font-medium text-foreground/75";
   const projectClass = tone === "switcher" ? "text-foreground/70" : isActive ? "text-foreground/80" : "text-foreground/60";
   const isSidebar = tone === "sidebar";
-  return /* @__PURE__ */ (0, import_jsx_runtime63.jsxs)("div", { className: "flex flex-col min-w-0 leading-tight", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("span", { className: cn(isSidebar ? "text-[13px]" : "text-sm", "truncate", nameClass), children: name3 }),
-    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("span", { className: cn(isSidebar ? "text-[11px]" : "text-xs", "truncate", projectClass), children: projectName })
+  return /* @__PURE__ */ (0, import_jsx_runtime63.jsxs)("div", { "data-testid": "workspace-label", className: "flex flex-col min-w-0 leading-tight", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(
+      "span",
+      {
+        "data-testid": "workspace-label__name",
+        className: cn(isSidebar ? "text-[13px]" : "text-sm", "truncate", nameClass),
+        children: name3
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(
+      "span",
+      {
+        "data-testid": "workspace-label__project",
+        className: cn(isSidebar ? "text-[11px]" : "text-xs", "truncate", projectClass),
+        children: projectName
+      }
+    )
   ] });
 }
 
@@ -131968,7 +132137,7 @@ var WorkspaceCard = (0, import_react29.memo)(function WorkspaceCard2({
   };
   const handleOpenChecks = () => {
     if (isDeleting) return;
-    showChecksTab();
+    showChecksTab(workspaceId2);
     if (!isActive) handleClick();
   };
   const className = `@container group flex flex-row items-center justify-between rounded-md pl-3 pr-2 py-1 min-h-9 min-w-0 overflow-hidden select-none touch-manipulation transition-colors ${isDeleting ? "cursor-not-allowed opacity-50" : "cursor-pointer hover:bg-accent/50"} [@media(pointer:coarse)]:min-h-11 [@media(pointer:coarse)]:py-2 ${isActive ? "bg-primary/15 hover:bg-primary/15" : isFocused ? "bg-accent" : ""} ${href ? "no-underline text-inherit" : ""}`;
@@ -141001,11 +141170,11 @@ var WorkspaceStatusSourceQueries = class {
   /** Every source in the workspace. */
   listForWorkspace(workspaceId2) {
     const db = getDb();
-    return db.select({
-      sourceId: workspaceStatusSources.sourceId,
-      status: workspaceStatusSources.status,
-      updatedAt: workspaceStatusSources.updatedAt
-    }).from(workspaceStatusSources).where(eq(workspaceStatusSources.workspaceId, workspaceId2)).all();
+    return db.select().from(workspaceStatusSources).where(eq(workspaceStatusSources.workspaceId, workspaceId2)).all();
+  }
+  /** Every source in every workspace. */
+  listAll() {
+    return getDb().select().from(workspaceStatusSources).all();
   }
   /** Delete one source; returns whether a row existed. */
   remove(workspaceId2, sourceId) {
@@ -141341,10 +141510,21 @@ function worktreesDir() {
   return settingsService.worktreesDir();
 }
 function loadCurrentStatuses() {
-  return workspaceStatusQueries.loadCurrent();
+  const sourcesByWorkspace = /* @__PURE__ */ new Map();
+  for (const source of statusSourceQueries.listAll()) {
+    const list3 = sourcesByWorkspace.get(source.workspaceId);
+    if (list3) list3.push(source);
+    else sourcesByWorkspace.set(source.workspaceId, [source]);
+  }
+  return workspaceStatusQueries.loadCurrent().map((status) => ({
+    ...status,
+    tabStatuses: toTabStatuses(sourcesByWorkspace.get(status.workspaceId) ?? [])
+  }));
 }
 function getWorkspaceStatus(workspaceId2) {
-  return workspaceStatusQueries.getByWorkspaceId(workspaceId2);
+  const status = workspaceStatusQueries.getByWorkspaceId(workspaceId2);
+  if (!status) return null;
+  return { ...status, tabStatuses: listTabStatuses(workspaceId2) };
 }
 function upsertWorkspaceStatus(workspaceId2, agent) {
   const existing = workspaceStatusQueries.findRow(workspaceId2);
@@ -141412,7 +141592,8 @@ function upsertWorkspaceStatus(workspaceId2, agent) {
       lastActivity: mergedAgent.agentLastActivity,
       summary: mergedAgent.agentSummary ?? void 0,
       codingAgentId: mergedAgent.codingAgentId ?? void 0
-    }
+    },
+    tabStatuses: listTabStatuses(workspaceId2)
   };
 }
 function resolveWorkspaceIdByCwd(cwd) {
@@ -141428,21 +141609,50 @@ function resolveWorkspaceIdByCwd(cwd) {
 }
 var STALE_HOOK_WORKING_MS = 15 * 6e4;
 var STATUS_PRIORITY = { needs_attention: 3, working: 2, waiting: 1 };
+var CHAT_SOURCE_PREFIX = "chat:";
 function chatStatusSource(chatId) {
-  return `chat:${chatId}`;
+  return `${CHAT_SOURCE_PREFIX}${chatId}`;
 }
 var MANUAL_STATUS_SOURCE = "manual";
+function isStaleSource({ sourceId, status, updatedAt }, staleBefore) {
+  return sourceId.startsWith("hook:") && status === "working" && updatedAt < staleBefore;
+}
 function deriveWorkspaceStatus(workspaceId2) {
   const staleBefore = Date.now() - STALE_HOOK_WORKING_MS;
   let best = null;
-  for (const { sourceId, status, updatedAt } of statusSourceQueries.listForWorkspace(workspaceId2)) {
-    if (sourceId.startsWith("hook:") && status === "working" && updatedAt < staleBefore) continue;
+  for (const source of statusSourceQueries.listForWorkspace(workspaceId2)) {
+    if (isStaleSource(source, staleBefore)) continue;
+    const { status } = source;
     if (best === null || (STATUS_PRIORITY[status] ?? 0) > (STATUS_PRIORITY[best] ?? 0)) {
       best = status;
     }
   }
   return best ?? "waiting";
 }
+function toTabStatuses(sources) {
+  const staleBefore = Date.now() - STALE_HOOK_WORKING_MS;
+  const byTab = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const { status } = source;
+    if (status !== "working" && status !== "needs_attention") continue;
+    if (isStaleSource(source, staleBefore)) continue;
+    let tab3;
+    if (source.sourceId.startsWith(CHAT_SOURCE_PREFIX)) {
+      tab3 = { chatId: source.sourceId.slice(CHAT_SOURCE_PREFIX.length), status };
+    } else if (source.terminalId) {
+      tab3 = { terminalId: source.terminalId, status };
+    } else {
+      continue;
+    }
+    const key2 = tab3.chatId ? `chat:${tab3.chatId}` : `terminal:${tab3.terminalId}`;
+    const prev = byTab.get(key2);
+    if (!prev || STATUS_PRIORITY[status] > STATUS_PRIORITY[prev.status]) byTab.set(key2, tab3);
+  }
+  return [...byTab.values()];
+}
+function listTabStatuses(workspaceId2) {
+  return toTabStatuses(statusSourceQueries.listForWorkspace(workspaceId2));
+}
 function setWorkspaceSourceStatus(workspaceId2, sourceId, agent) {
   statusSourceQueries.upsert({
     workspaceId: workspaceId2,
@@ -143655,6 +143865,7 @@ var TerminalPool = class {
     delete env.FORCE_COLOR;
     delete env.CLICOLOR;
     env.COLORFGBG = "15;0";
+    env.CLAUDE_CODE_FORCE_SYNC_OUTPUT = "1";
     delete env.PORT;
     if (options2?.env) {
       Object.assign(env, options2.env);
@@ -145503,6 +145714,25 @@ function submitTask(options2) {
   });
   return toTaskInfo(task);
 }
+function submitOrQueueTask(options2) {
+  const { workspaceId: workspaceId2, chatId } = options2;
+  if (!workspaceService.resolve(workspaceId2)) {
+    throw new WorkspaceNotFoundError(workspaceId2);
+  }
+  const running = tasks2.get(chatId)?.status === "running";
+  if (!running && !hasQueuedMessages(chatId)) {
+    return { queued: false, task: submitTask(options2) };
+  }
+  const queued = pushQueuedMessage(chatId, {
+    text: options2.prompt,
+    files: options2.attachments,
+    mode: options2.mode,
+    model: options2.model,
+    codingAgentId: options2.codingAgentId
+  });
+  if (!running) drainQueue(workspaceId2, chatId);
+  return { queued: true, queuedMessageId: queued.id };
+}
 async function runTask(task) {
   const { chatId } = task;
   chatService.updateStatus(chatId, "running");
@@ -145632,7 +145862,7 @@ function finishTask(task, outcome) {
   task.completedAt = Date.now();
   persistTask(task);
   if (tasks2.get(task.chatId) === task) tasks2.delete(task.chatId);
-  if (status === "completed" && drainQueue(task)) return;
+  if (status === "completed" && drainQueue(task.workspaceId, task.chatId)) return;
   chatService.updateStatus(task.chatId, status === "completed" ? "idle" : "error");
   const stopped = outcome === "cancelled" || task.cancelRequested === true;
   const updated = setWorkspaceSourceStatus(task.workspaceId, chatStatusSource(task.chatId), {
@@ -145640,20 +145870,24 @@ function finishTask(task, outcome) {
   });
   emit({ kind: "update", status: updated });
 }
-function drainQueue(task) {
-  const queued = shiftQueuedMessage(task.chatId);
+function drainQueue(workspaceId2, chatId) {
+  const queued = peekQueuedMessage(chatId);
   if (!queued) return false;
   try {
     const attachments = (queued.files ?? []).filter((f2) => f2.path).map((f2) => ({ path: f2.path, mediaType: f2.mediaType, url: f2.url, filename: f2.filename }));
     submitTask({
-      workspaceId: task.workspaceId,
-      chatId: task.chatId,
+      workspaceId: workspaceId2,
+      chatId,
       prompt: queued.text,
-      attachments
+      attachments,
+      mode: queued.mode,
+      model: queued.model,
+      codingAgentId: queued.codingAgentId
     });
+    removeQueuedMessage(chatId, queued.id);
     return true;
   } catch (err) {
-    log19.warn({ chatId: task.chatId, err }, "failed to auto-start queued task");
+    log19.warn({ chatId, err }, "failed to auto-start queued task");
     return false;
   }
 }
@@ -145700,6 +145934,9 @@ var TaskService = class {
   submitTask(options2) {
     return submitTask(options2);
   }
+  submitOrQueueTask(options2) {
+    return submitOrQueueTask(options2);
+  }
   abortTask(chatId) {
     return abortTask(chatId);
   }
@@ -149584,6 +149821,7 @@ var chatService = new ChatService();
 var log31 = createLogger("agent-sessions");
 var IDLE_TIMEOUT_MS = 15 * 6e4;
 var CANCEL_GRACE_MS = 15e3;
+var MAX_TIMER_MS = 2 ** 31 - 1;
 var PROBE_SETTLE_MS = 1500;
 var events = new ChatEventQueries();
 var settings = new SettingsQueries();
@@ -149662,6 +149900,7 @@ function runtimeFor(chat, def2) {
       turnSeq: 0,
       live: emptyLive(),
       pending: /* @__PURE__ */ new Map(),
+      work: new PendingWork(),
       idleTimer: null,
       claudeCli: null
     };
@@ -149677,19 +149916,41 @@ function stopRuntime(rt) {
   rt.sessionId = null;
   runtimes.delete(rt.chatId);
 }
-function scheduleIdle(rt) {
+function idleTimeoutMs() {
+  const override = Number(process.env.BAND_AGENT_IDLE_TIMEOUT_MS);
+  return Number.isFinite(override) && override > 0 ? override : IDLE_TIMEOUT_MS;
+}
+function scheduleIdle(rt, delayMs = idleTimeoutMs()) {
   if (rt.idleTimer) clearTimeout(rt.idleTimer);
+  const delay2 = Math.min(delayMs, MAX_TIMER_MS);
   rt.idleTimer = setTimeout(() => {
     rt.idleTimer = null;
     if (rt.inTurn || rt.pending.size > 0 || rt.attaching) return;
+    const now = Date.now();
+    const holds = rt.work.outstanding(now);
+    if (holds.length > 0) {
+      const until = Math.max(...holds.map((h) => h.until));
+      log31.info(
+        {
+          chatId: rt.chatId,
+          work: holds.map((h) => ({ reason: h.reason, until: new Date(h.until).toISOString() }))
+        },
+        "idle agent has pending work; not stopping it"
+      );
+      scheduleIdle(rt, until - now + idleTimeoutMs());
+      return;
+    }
     log31.info({ chatId: rt.chatId }, "stopping idle agent");
     rt.process?.close();
     rt.process = null;
     rt.sessionId = null;
     if (runtimes.get(rt.chatId) === rt) runtimes.delete(rt.chatId);
-  }, IDLE_TIMEOUT_MS);
+  }, delay2);
   rt.idleTimer.unref?.();
 }
+function agentActive(rt) {
+  if (!rt.inTurn && !rt.attaching && rt.process) scheduleIdle(rt);
+}
 function record2(rt, event, turnStart = false) {
   if (!rt.sessionId) {
     broadcastTransient(rt.chatId, event);
@@ -149805,6 +150066,10 @@ function routeUpdate(rt, notification) {
   }
   const update = notification.update;
   applyLive(rt, update);
+  if (!rt.attaching) {
+    rt.work.observeUpdate(update, rt.inTurn);
+    agentActive(rt);
+  }
   if (rt.routing === "drop") return;
   if (update.sessionUpdate === "user_message_chunk") {
     if (rt.inTurn) return;
@@ -149875,6 +150140,11 @@ function requestElicitation(rt, request, signal) {
 function handlersFor(rt, generation) {
   return {
     onUpdate: (n) => routeUpdate(rt, n),
+    onAsyncTask: (n) => {
+      if (n.sessionId !== rt.sessionId || rt.attaching) return;
+      rt.work.observeAsyncTask(n.update);
+      agentActive(rt);
+    },
     onPermission: (req, signal) => requestPermission(rt, req, signal),
     onElicitation: (req, signal) => requestElicitation(rt, req, signal),
     onExit: (code, stderr) => {
@@ -149882,6 +150152,7 @@ function handlersFor(rt, generation) {
       log31.info({ chatId: rt.chatId, code }, "agent exited");
       log31.debug({ chatId: rt.chatId, stderr: stderr.slice(-500) }, "agent stderr");
       for (const p3 of [...rt.pending.values()]) p3.cancel();
+      rt.work.clear();
       rt.process = null;
       rt.starting = null;
     }
@@ -150844,7 +151115,7 @@ async function handleChatSubmit(req, res, chatId) {
     }));
   }
   try {
-    taskService.submitTask({
+    const result = taskService.submitOrQueueTask({
       workspaceId: workspaceId2,
       chatId,
       prompt: text3,
@@ -150854,18 +151125,12 @@ async function handleChatSubmit(req, res, chatId) {
       model,
       codingAgentId
     });
-    log33.info({ chatId, workspaceId: workspaceId2 }, "chat-submit: task started");
-    sendJson2(res, 200, { ok: true, queued: false });
+    log33.info(
+      { chatId, workspaceId: workspaceId2 },
+      result.queued ? "chat-submit: chat busy, message queued" : "chat-submit: task started"
+    );
+    sendJson2(res, 200, { ok: true, queued: result.queued });
   } catch (err) {
-    if (err instanceof TaskConflictError) {
-      pushQueuedMessage(chatId, {
-        text: text3,
-        ...attachments.length > 0 && { files: attachments }
-      });
-      log33.info({ chatId, workspaceId: workspaceId2 }, "chat-submit: task busy, message queued");
-      sendJson2(res, 200, { ok: true, queued: true });
-      return;
-    }
     if (err instanceof WorkspaceNotFoundError) {
       sendJson2(res, 404, { error: err.message });
       return;
@@ -155807,7 +156072,7 @@ var McpServer = class {
   /**
    * Validates tool input arguments against the tool's input schema.
    */
-  async validateToolInput(tool, args, toolName) {
+  async validateToolInput(tool, args, toolName2) {
     if (!tool.inputSchema) {
       return void 0;
     }
@@ -155817,14 +156082,14 @@ var McpServer = class {
     if (!parseResult.success) {
       const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error40);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName2}: ${errorMessage}`);
     }
     return parseResult.data;
   }
   /**
    * Validates tool output against the tool's output schema.
    */
-  async validateToolOutput(tool, result, toolName) {
+  async validateToolOutput(tool, result, toolName2) {
     if (!tool.outputSchema) {
       return;
     }
@@ -155835,14 +156100,14 @@ var McpServer = class {
       return;
     }
     if (!result.structuredContent) {
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName2} has an output schema but no structured content was provided`);
     }
     const outputObj = normalizeObjectSchema(tool.outputSchema);
     const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error40);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName2}: ${errorMessage}`);
     }
   }
   /**
@@ -158627,23 +158892,25 @@ var chatsRouter = t3.router({
     if (!chat) {
       chat = chatService.create(input.workspaceId, { id: input.chatId, name: "Chat" });
     }
-    try {
-      const task = taskService.submitTask({
-        workspaceId: chat.workspaceId,
-        chatId: chat.id,
-        prompt: input.message,
-        sessionId: input.sessionId
-      });
-      return { taskId: task.id, sessionId: task.sessionId };
-    } catch (err) {
-      if (err instanceof TaskConflictError) {
-        throw new TRPCError({
-          code: "CONFLICT",
-          message: "Task already running for this chat pane"
-        });
-      }
-      throw err;
+    const result = taskService.submitOrQueueTask({
+      workspaceId: chat.workspaceId,
+      chatId: chat.id,
+      prompt: input.message,
+      sessionId: input.sessionId
+    });
+    if (result.queued) {
+      return {
+        queued: true,
+        queuedMessageId: result.queuedMessageId,
+        taskId: null,
+        sessionId: null
+      };
     }
+    return {
+      queued: false,
+      taskId: result.task.id,
+      sessionId: result.task.sessionId
+    };
   }),
   stop: publicProcedure.input(external_exports2.object({ chatId: external_exports2.string() })).mutation(({ input }) => {
     taskService.abortTask(input.chatId);
@@ -162148,7 +162415,7 @@ var tasksRouter = t3.router({
       }));
     }
     try {
-      const task = taskService.submitTask({
+      const result = taskService.submitOrQueueTask({
         workspaceId: input.workspaceId,
         chatId,
         prompt: input.prompt,
@@ -162158,7 +162425,19 @@ var tasksRouter = t3.router({
         model: input.model,
         codingAgentId: input.codingAgentId
       });
+      if (result.queued) {
+        return {
+          queued: true,
+          id: null,
+          queuedMessageId: result.queuedMessageId,
+          workspaceId: input.workspaceId,
+          chatId,
+          sessionId: null
+        };
+      }
+      const { task } = result;
       return {
+        queued: false,
         id: task.id,
         workspaceId: task.workspaceId,
         chatId: task.chatId,
@@ -164993,10 +165272,10 @@ function discoverProcedures() {
   for (const [path, procedure] of Object.entries(procRecord)) {
     const type = procedure._def.type;
     if (type === "subscription") continue;
-    const toolName = `band_${path.replace(/\./g, "_")}`;
+    const toolName2 = `band_${path.replace(/\./g, "_")}`;
     const inputs = procedure._def.inputs;
     const inputSchema = inputs.length > 0 ? inputs[0] : void 0;
-    procedures.push({ path, toolName, type, inputSchema });
+    procedures.push({ path, toolName: toolName2, type, inputSchema });
   }
   return procedures;
 }