@usabledev/usable-chat 1.152.1 → 1.154.0

package/cli.js

@@ -77609,11 +77609,11 @@ var require_randomUUID = __commonJS({
 var require_dist_cjs31 = __commonJS({
   "node_modules/.pnpm/@smithy+uuid@1.1.2/node_modules/@smithy/uuid/dist-cjs/index.js"(exports) {
     "use strict";
-    var randomUUID7 = require_randomUUID();
+    var randomUUID8 = require_randomUUID();
     var decimalToHex = Array.from({ length: 256 }, (_16, i18) => i18.toString(16).padStart(2, "0"));
     var v42 = () => {
-      if (randomUUID7.randomUUID) {
-        return randomUUID7.randomUUID();
+      if (randomUUID8.randomUUID) {
+        return randomUUID8.randomUUID();
       }
       const rnds = new Uint8Array(16);
       crypto.getRandomValues(rnds);
@@ -131517,7 +131517,7 @@ var require_gaxios = __commonJS({
     var retry_js_1 = require_retry();
     var stream_1 = __require("stream");
     var interceptor_js_1 = require_interceptor();
-    var randomUUID7 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+    var randomUUID8 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
     var HTTP_STATUS_NO_CONTENT = 204;
     var Gaxios = class {
       agentCache = /* @__PURE__ */ new Map();
@@ -131790,7 +131790,7 @@ var require_gaxios = __commonJS({
          */
         ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
         if (opts.multipart?.length) {
-          const boundary = await randomUUID7();
+          const boundary = await randomUUID8();
           preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
           opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
         } else if (shouldDirectlyPassData) {
@@ -162589,6 +162589,7 @@ async function adaptOpenRouterStream(stream, options2) {
   let finishReason = null;
   const toolCalls = [];
   const completedToolCalls = [];
+  const toolExecutionPromises = [];
   const toolResults = [];
   let capturedUsage;
   let capturedModel;
@@ -162598,6 +162599,188 @@ async function adaptOpenRouterStream(stream, options2) {
   let lastEmittedReasoning = "";
   const accumulatedReasoningDetails = [];
   const pendingToolCalls = /* @__PURE__ */ new Map();
+  const executeParsedToolCall = async (id, name18, args) => {
+    if (context.abortSignal?.aborted) {
+      streamLogger.info("Abort signal detected before tool execution, returning cancelled result", {
+        toolName: name18
+      });
+      const errorResult = { error: "Request cancelled by user", success: false };
+      toolCalls.push({ toolName: name18, success: false });
+      toolResults.push({ id, name: name18, result: errorResult, isError: true });
+      const errorEvent = emitter.emit("tool-result", {
+        id,
+        toolName: name18,
+        input: args,
+        result: errorResult,
+        success: false,
+        error: errorResult.error
+      });
+      multiplexer.send(errorEvent);
+      return;
+    }
+    streamLogger.debug("Executing tool", { toolName: name18, args });
+    try {
+      const toolResult = await executeTool3(name18, args, {
+        ...context,
+        toolCallId: id
+      });
+      const success2 = !toolResult?.error;
+      toolCalls.push({ toolName: name18, success: success2 });
+      toolResults.push({ id, name: name18, result: toolResult, isError: !success2 });
+      if (context.session) {
+        if (!context.session.toolHistory) {
+          context.session.toolHistory = [];
+        }
+        const toolHistory = context.session.toolHistory;
+        toolHistory.push({
+          toolName: name18,
+          args,
+          result: toolResult,
+          success: success2,
+          timestamp: Date.now()
+        });
+        if (toolHistory.length > 50) {
+          toolHistory.shift();
+        }
+      }
+      const toolResultEvent = emitter.emit("tool-result", {
+        id,
+        toolName: name18,
+        input: args,
+        result: toolResult,
+        success: success2,
+        error: toolResult?.error ? String(toolResult.error) : void 0
+      });
+      multiplexer.send(toolResultEvent);
+      if (name18 === "check-context-window" && success2 && toolResult?.data) {
+        const data2 = toolResult.data;
+        const breakdown = data2.breakdown.systemPrompt !== void 0 ? {
+          systemPrompts: data2.breakdown.systemPrompt + (data2.breakdown.systemTools || 0),
+          contextTokens: data2.breakdown.memoryFiles || 0,
+          toolCallsAndResponses: data2.breakdown.toolUseAndResults || 0,
+          userQuestions: 0,
+          assistantMessages: data2.breakdown.messages || 0
+        } : data2.breakdown;
+        const cardEvent = emitter.emit("card", {
+          component: "context-window",
+          data: {
+            totalTokens: data2.totalTokens,
+            maxTokens: data2.maxTokens,
+            percentage: data2.percentage,
+            breakdown,
+            freeSpace: data2.freeSpace,
+            contextItems: data2.contextItems || {
+              workspaces: 0,
+              fragments: 0,
+              toolResults: 0
+            }
+          }
+        });
+        multiplexer.send(cardEvent);
+      }
+      if (isAskQuestionPause(toolResult)) {
+        pauseDetected = true;
+        if (onPauseDetected) {
+          await onPauseDetected({
+            resumeToken: toolResult.__pause.resumeToken,
+            questions: toolResult.__pause.questions,
+            context: toolResult.__pause.context
+          });
+        }
+        return;
+      }
+      if (toolResult?.__parentToolCall === true) {
+        const parentToolName = toolResult.toolName;
+        const parentToolArgs = toolResult.args;
+        const requestId = `parent_${id}_${Date.now()}`;
+        streamLogger.info("Parent tool call detected - waiting for parent response", {
+          toolName: name18,
+          parentToolName,
+          requestId
+        });
+        const parentToolEvent = emitter.emit("parent-tool-call", {
+          requestId,
+          toolName: parentToolName,
+          args: parentToolArgs
+        });
+        multiplexer.send(parentToolEvent);
+        try {
+          const parentResponse = await waitForParentToolResponse(
+            requestId,
+            parentToolName,
+            parentToolArgs,
+            3e4
+          );
+          streamLogger.info("Parent tool response received", {
+            requestId,
+            parentToolName,
+            hasResult: parentResponse !== void 0
+          });
+          const resultIndex = toolResults.findIndex((r17) => r17.id === id);
+          if (resultIndex !== -1) {
+            toolResults[resultIndex].result = parentResponse;
+          }
+          const updatedResultEvent = emitter.emit("tool-result", {
+            id,
+            toolName: name18,
+            input: args,
+            result: parentResponse,
+            success: true
+          });
+          multiplexer.send(updatedResultEvent);
+        } catch (parentError) {
+          streamLogger.error("Parent tool call failed", {
+            requestId,
+            parentToolName,
+            error: parentError instanceof Error ? parentError.message : String(parentError)
+          });
+          const errorResult = {
+            error: parentError instanceof Error ? parentError.message : String(parentError),
+            success: false
+          };
+          const resultIndex = toolResults.findIndex((r17) => r17.id === id);
+          if (resultIndex !== -1) {
+            toolResults[resultIndex].result = errorResult;
+            toolResults[resultIndex].isError = true;
+          }
+          const errorEvent = emitter.emit("tool-result", {
+            id,
+            toolName: name18,
+            input: args,
+            result: errorResult,
+            success: false,
+            error: parentError instanceof Error ? parentError.message : String(parentError)
+          });
+          multiplexer.send(errorEvent);
+        }
+      }
+      if (emitObservations && success2) {
+        const observation = generateObservation2(name18, toolResult);
+        const observationEvent = emitter.emit("observation", {
+          observation,
+          toolCallIds: [id]
+        });
+        multiplexer.send(observationEvent);
+      }
+    } catch (toolError) {
+      console.error(`\u274C Tool execution error for ${name18}:`, toolError);
+      toolCalls.push({ toolName: name18, success: false });
+      const errorResult = {
+        error: toolError instanceof Error ? toolError.message : String(toolError),
+        success: false
+      };
+      toolResults.push({ id, name: name18, result: errorResult, isError: true });
+      const errorEvent = emitter.emit("tool-result", {
+        id,
+        toolName: name18,
+        input: args,
+        result: null,
+        success: false,
+        error: toolError instanceof Error ? toolError.message : String(toolError)
+      });
+      multiplexer.send(errorEvent);
+    }
+  };
   try {
     while (true) {
       if (context.abortSignal?.aborted) {
@@ -162855,187 +163038,9 @@ async function adaptOpenRouterStream(stream, options2) {
                 });
                 multiplexer.send(retrievalEvent);
               }
-              if (context.abortSignal?.aborted) {
-                streamLogger.info("Abort signal detected before tool execution, skipping", {
-                  toolName: pending.name
-                });
-                break;
-              }
-              streamLogger.debug("Executing tool", {
-                toolName: pending.name,
-                args
-              });
-              try {
-                const toolResult = await executeTool3(pending.name, args, { ...context, toolCallId: pending.id });
-                const success2 = !toolResult?.error;
-                toolCalls.push({ toolName: pending.name, success: success2 });
-                toolResults.push({
-                  id: pending.id,
-                  name: pending.name,
-                  result: toolResult,
-                  isError: !success2
-                });
-                if (context.session) {
-                  if (!context.session.toolHistory) {
-                    context.session.toolHistory = [];
-                  }
-                  const toolHistory = context.session.toolHistory;
-                  toolHistory.push({
-                    toolName: pending.name,
-                    args,
-                    result: toolResult,
-                    success: success2,
-                    timestamp: Date.now()
-                  });
-                  if (toolHistory.length > 50) {
-                    toolHistory.shift();
-                  }
-                }
-                const toolResultEvent = emitter.emit("tool-result", {
-                  id: pending.id,
-                  toolName: pending.name,
-                  input: args,
-                  // Include input arguments
-                  result: toolResult,
-                  success: success2,
-                  error: toolResult?.error ? String(toolResult.error) : void 0
-                });
-                multiplexer.send(toolResultEvent);
-                if (pending.name === "check-context-window" && success2 && toolResult?.data) {
-                  const data2 = toolResult.data;
-                  const breakdown = data2.breakdown.systemPrompt !== void 0 ? {
-                    // New format - map to old format
-                    systemPrompts: data2.breakdown.systemPrompt + (data2.breakdown.systemTools || 0),
-                    contextTokens: data2.breakdown.memoryFiles || 0,
-                    toolCallsAndResponses: data2.breakdown.toolUseAndResults || 0,
-                    userQuestions: 0,
-                    // Will be calculated from messages
-                    assistantMessages: data2.breakdown.messages || 0
-                  } : data2.breakdown;
-                  const cardEvent = emitter.emit("card", {
-                    component: "context-window",
-                    data: {
-                      totalTokens: data2.totalTokens,
-                      maxTokens: data2.maxTokens,
-                      percentage: data2.percentage,
-                      breakdown,
-                      freeSpace: data2.freeSpace,
-                      contextItems: data2.contextItems || {
-                        workspaces: 0,
-                        fragments: 0,
-                        toolResults: 0
-                      }
-                    }
-                  });
-                  multiplexer.send(cardEvent);
-                }
-                if (isAskQuestionPause(toolResult)) {
-                  pauseDetected = true;
-                  if (onPauseDetected) {
-                    await onPauseDetected({
-                      resumeToken: toolResult.__pause.resumeToken,
-                      questions: toolResult.__pause.questions,
-                      context: toolResult.__pause.context
-                    });
-                  }
-                  break;
-                }
-                if (toolResult?.__parentToolCall === true) {
-                  const parentToolName = toolResult.toolName;
-                  const parentToolArgs = toolResult.args;
-                  const requestId = `parent_${pending.id}_${Date.now()}`;
-                  streamLogger.info("Parent tool call detected - waiting for parent response", {
-                    toolName: pending.name,
-                    parentToolName,
-                    requestId
-                  });
-                  const parentToolEvent = emitter.emit("parent-tool-call", {
-                    requestId,
-                    toolName: parentToolName,
-                    args: parentToolArgs
-                  });
-                  multiplexer.send(parentToolEvent);
-                  try {
-                    const parentResponse = await waitForParentToolResponse(
-                      requestId,
-                      parentToolName,
-                      parentToolArgs,
-                      3e4
-                      // 30 second timeout
-                    );
-                    streamLogger.info("Parent tool response received", {
-                      requestId,
-                      parentToolName,
-                      hasResult: parentResponse !== void 0
-                    });
-                    const resultIndex = toolResults.findIndex((r17) => r17.id === pending.id);
-                    if (resultIndex !== -1) {
-                      toolResults[resultIndex].result = parentResponse;
-                    }
-                    const updatedResultEvent = emitter.emit("tool-result", {
-                      id: pending.id,
-                      toolName: pending.name,
-                      input: args,
-                      result: parentResponse,
-                      success: true
-                    });
-                    multiplexer.send(updatedResultEvent);
-                  } catch (parentError) {
-                    streamLogger.error("Parent tool call failed", {
-                      requestId,
-                      parentToolName,
-                      error: parentError instanceof Error ? parentError.message : String(parentError)
-                    });
-                    const errorResult = {
-                      error: parentError instanceof Error ? parentError.message : String(parentError),
-                      success: false
-                    };
-                    const resultIndex = toolResults.findIndex((r17) => r17.id === pending.id);
-                    if (resultIndex !== -1) {
-                      toolResults[resultIndex].result = errorResult;
-                      toolResults[resultIndex].isError = true;
-                    }
-                    const errorEvent = emitter.emit("tool-result", {
-                      id: pending.id,
-                      toolName: pending.name,
-                      input: args,
-                      result: errorResult,
-                      success: false,
-                      error: parentError instanceof Error ? parentError.message : String(parentError)
-                    });
-                    multiplexer.send(errorEvent);
-                  }
-                }
-                if (emitObservations && success2) {
-                  const observation = generateObservation2(pending.name, toolResult);
-                  const observationEvent = emitter.emit("observation", {
-                    observation,
-                    toolCallIds: [pending.id]
-                  });
-                  multiplexer.send(observationEvent);
-                }
-              } catch (toolError) {
-                console.error(`\u274C Tool execution error for ${pending.name}:`, toolError);
-                toolCalls.push({ toolName: pending.name, success: false });
-                const errorResult = {
-                  error: toolError instanceof Error ? toolError.message : String(toolError),
-                  success: false
-                };
-                toolResults.push({
-                  id: pending.id,
-                  name: pending.name,
-                  result: errorResult,
-                  isError: true
-                });
-                const errorEvent = emitter.emit("tool-result", {
-                  id: pending.id,
-                  toolName: pending.name,
-                  result: null,
-                  success: false,
-                  error: toolError instanceof Error ? toolError.message : String(toolError)
-                });
-                multiplexer.send(errorEvent);
-              }
+              toolExecutionPromises.push(
+                executeParsedToolCall(pending.id, pending.name, args)
+              );
               pendingToolCalls.delete(index2);
             } catch {
             }
@@ -163048,6 +163053,13 @@ async function adaptOpenRouterStream(stream, options2) {
           finishReason: finish_reason,
           hasUsage: !!capturedUsage
         });
+        if (finish_reason === "tool_calls" && toolExecutionPromises.length > 0) {
+          streamLogger.debug("Waiting for OpenRouter tool executions", {
+            toolCount: toolExecutionPromises.length
+          });
+          await Promise.allSettled(toolExecutionPromises);
+          toolExecutionPromises.length = 0;
+        }
         if (finish_reason !== "tool_calls" && !summaryEmitted) {
           if (capturedUsage && (capturedUsage.completion_tokens ?? 0) > 0) {
             const usageData = {
@@ -163082,6 +163094,13 @@ async function adaptOpenRouterStream(stream, options2) {
         }
       }
     }
+    if (toolExecutionPromises.length > 0) {
+      streamLogger.debug("Waiting for pending OpenRouter tool executions after stream end", {
+        toolCount: toolExecutionPromises.length
+      });
+      await Promise.allSettled(toolExecutionPromises);
+      toolExecutionPromises.length = 0;
+    }
     if (finishReason && !summaryEmitted && finishReason !== "tool_calls") {
       streamLogger.warn("Stream ended without usage chunk - emitting summary without usage", {
         finishReason
@@ -175976,6 +175995,33 @@ data: ${JSON.stringify(envelope)}
 });
 
 // src/core/tools/spawn-subagent.ts
+async function maybeStartBackgroundRelay(redis, context, conversationId, taskId, success2) {
+  if (!redis || !context.startBackgroundSubagentRelay) return false;
+  try {
+    const record2 = await spawnedTaskStore.get(redis, taskId);
+    if (record2?.notifiedTurnAt) {
+      return true;
+    }
+    const lockKey = `subagents:background-relay-lock:${conversationId}`;
+    const acquired = await redis.set(lockKey, taskId, "NX", "EX", 180).catch(() => null);
+    if (!acquired) {
+      return true;
+    }
+    const started = await context.startBackgroundSubagentRelay({
+      conversationId,
+      taskId,
+      reason: success2 ? "completed" : "failed"
+    });
+    return started;
+  } catch (err) {
+    logger.debug("SpawnSubagent", "Failed to start background relay job", {
+      conversationId,
+      taskId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  }
+}
 async function maybeEmitPingPrompt(redis, conversationId, taskId) {
   if (!redis) return;
   try {
@@ -176276,7 +176322,10 @@ HOW TO USE THIS:
                 tokenUsage: response.tokenUsage
               }
             });
-            await maybeEmitPingPrompt(redis, conversationId, taskId);
+            const relayed = await maybeStartBackgroundRelay(redis, context, conversationId, taskId, success2);
+            if (!relayed) {
+              await maybeEmitPingPrompt(redis, conversationId, taskId);
+            }
           } catch (err) {
             const errorMessage = err instanceof Error ? err.message : String(err);
             const status = abort.signal.aborted ? "cancelled" : "failed";
@@ -176291,7 +176340,10 @@ HOW TO USE THIS:
               taskId,
               data: { error: errorMessage }
             });
-            await maybeEmitPingPrompt(redis, conversationId, taskId);
+            const relayed = await maybeStartBackgroundRelay(redis, context, conversationId, taskId, false);
+            if (!relayed) {
+              await maybeEmitPingPrompt(redis, conversationId, taskId);
+            }
           } finally {
             spawnedTaskStore.unregisterLocalAbort(taskId);
           }
@@ -249322,7 +249374,8 @@ async function orchestrate(request) {
     chatMode,
     imageGenModel: context.metadata?.imageGenModel,
     imageGenThinking: context.metadata?.imageGenThinking,
-    registeredParentToolSchemas: context.registeredParentToolSchemas
+    registeredParentToolSchemas: context.registeredParentToolSchemas,
+    startBackgroundSubagentRelay: context.startBackgroundSubagentRelay
   });
   if (!config3.localFilesystem) {
     aiTools["spawn_subagent"] = {
@@ -252400,6 +252453,7 @@ function createOrchestratorRequest(messages4, context, config3, persona, apiKey,
       metadata: context.metadata,
       allowedWorkspaceIds: context.allowedWorkspaceIds,
       registeredParentToolSchemas: context.registeredParentToolSchemas,
+      startBackgroundSubagentRelay: context.startBackgroundSubagentRelay,
       extensions: context.extensions
       // Plugin hook seam (CLI only; undefined on web)
     },
@@ -254193,6 +254247,7 @@ var init_skills3 = __esm({
 // src/adapters/cli/subagent.ts
 import { spawn as spawn5 } from "node:child_process";
 import { basename as basename8 } from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function currentSubagentDepth() {
   const d21 = Number(process.env.USABLE_SUBAGENT_DEPTH ?? 0);
   return Number.isFinite(d21) && d21 > 0 ? Math.floor(d21) : 0;
@@ -254277,11 +254332,73 @@ async function runCliSubagent(input) {
   }
   return { ok: true, text: res.out.trim() };
 }
+function publicTask(task) {
+  return {
+    taskId: task.taskId,
+    status: task.status,
+    prompt: task.prompt,
+    model: task.model,
+    cwd: task.cwd,
+    startedAt: task.startedAt,
+    completedAt: task.completedAt,
+    ...task.text ? { text: task.text } : {},
+    ...task.error ? { error: task.error } : {}
+  };
+}
+function startCliSubagentTask(input) {
+  const taskId = input.taskId ?? randomUUID6();
+  const abortController = new AbortController();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const run2 = input._run ?? runCliSubagent;
+  const onParentAbort = () => abortController.abort();
+  input.parentAbortSignal?.addEventListener("abort", onParentAbort, { once: true });
+  const task = {
+    taskId,
+    prompt: input.prompt,
+    model: input.model,
+    cwd: input.cwd,
+    status: "running",
+    startedAt,
+    abortController,
+    promise: Promise.resolve(void 0)
+  };
+  task.promise = (async () => {
+    try {
+      const res = await run2({
+        prompt: input.prompt,
+        model: input.model,
+        cwd: input.cwd,
+        abortSignal: abortController.signal,
+        timeoutMs: input.timeoutMs
+      });
+      task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (abortController.signal.aborted) {
+        task.status = "cancelled";
+        task.error = "subagent cancelled";
+      } else if (res.ok) {
+        task.status = "completed";
+        task.text = res.text;
+      } else {
+        task.status = "failed";
+        task.text = res.text;
+        task.error = res.error ?? "subagent failed";
+      }
+    } catch (err) {
+      task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      task.status = abortController.signal.aborted ? "cancelled" : "failed";
+      task.error = err instanceof Error ? err.message : String(err);
+    } finally {
+      input.parentAbortSignal?.removeEventListener("abort", onParentAbort);
+    }
+    return task;
+  })();
+  cliSubagentTasks.set(taskId, task);
+  return task;
+}
 function buildCliSubagentTool(opts) {
-  const run2 = opts._run ?? runCliSubagent;
   return {
     spawn_subagent: {
-      description: SPAWN_DESCRIPTION,
+      description: ASYNC_SPAWN_DESCRIPTION,
       parameters: {
         type: "object",
         properties: {
@@ -254300,31 +254417,89 @@ function buildCliSubagentTool(opts) {
         const prompt = String(args.prompt ?? "").trim();
         if (!prompt) return { error: "prompt is required" };
         const model = typeof args.model === "string" && args.model.trim() ? args.model.trim() : opts.model;
-        const res = await run2({
+        const task = startCliSubagentTask({
+          taskId: typeof args.taskId === "string" && args.taskId.trim() ? args.taskId.trim() : void 0,
           prompt,
           model,
           cwd: process.cwd(),
-          abortSignal: opts.abortSignal
+          parentAbortSignal: opts.abortSignal,
+          _run: opts._run
         });
-        if (!res.ok) {
-          return { error: res.error ?? "subagent failed", ...res.text ? { partial: res.text } : {} };
+        return publicTask(task);
+      }
+    },
+    list_subagents: {
+      description: "List background CLI subagents in this process. Use this before awaiting when you need task ids or status.",
+      parameters: {
+        type: "object",
+        properties: {
+          includeFinished: {
+            type: "boolean",
+            description: "Include completed, failed, and cancelled tasks. Defaults to true."
+          }
+        }
+      },
+      execute: async (args) => {
+        const includeFinished = args.includeFinished !== false;
+        const tasks = [...cliSubagentTasks.values()].filter(
+          (task) => includeFinished || task.status === "running"
+        );
+        return { tasks: tasks.map(publicTask) };
+      }
+    },
+    await_subagents: {
+      description: "Wait for one or more background CLI subagents and collect their results. Omit taskIds to wait for all running tasks.",
+      parameters: {
+        type: "object",
+        properties: {
+          taskIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Specific task ids to wait for. Defaults to all running tasks."
+          },
+          timeout: {
+            type: "number",
+            description: "Maximum seconds to wait. Defaults to 300."
+          }
+        }
+      },
+      execute: async (args) => {
+        const ids = Array.isArray(args.taskIds) ? args.taskIds.filter((id) => typeof id === "string" && id.length > 0) : [...cliSubagentTasks.values()].filter((task) => task.status === "running").map((task) => task.taskId);
+        const tasks = ids.map((id) => cliSubagentTasks.get(id));
+        const missing = ids.filter((id, index2) => !tasks[index2]);
+        const existing = tasks.filter((task) => !!task);
+        if (missing.length > 0) return { error: `Unknown subagent task id(s): ${missing.join(", ")}` };
+        if (existing.length === 0) return { results: [] };
+        const timeoutS = typeof args.timeout === "number" && Number.isFinite(args.timeout) ? Math.max(1, args.timeout) : 300;
+        const timeout = new Promise(
+          (resolve8) => setTimeout(() => resolve8("timeout"), timeoutS * 1e3)
+        );
+        const settled = await Promise.race([
+          Promise.all(existing.map((task) => task.promise)),
+          timeout
+        ]);
+        if (settled === "timeout") {
+          return {
+            error: `Timed out waiting for subagents after ${timeoutS}s`,
+            pending: existing.filter((task) => task.status === "running").map(publicTask),
+            results: existing.filter((task) => task.status !== "running").map(publicTask)
+          };
         }
-        return { result: res.text };
+        return { results: settled.map(publicTask) };
       }
     }
   };
 }
-var SUBAGENT_TIMEOUT_MS, SUBAGENT_MAX_DEPTH, SPAWN_DESCRIPTION;
+var SUBAGENT_TIMEOUT_MS, SUBAGENT_MAX_DEPTH, cliSubagentTasks, ASYNC_SPAWN_DESCRIPTION;
 var init_subagent = __esm({
   "src/adapters/cli/subagent.ts"() {
     "use strict";
     SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
     SUBAGENT_MAX_DEPTH = 2;
-    SPAWN_DESCRIPTION = `Spawn a subagent to handle a self-contained task and return its findings directly.
-
-The subagent is a fresh \`usable-chat\` agent running in YOUR current working directory, with the SAME model/provider and the same real filesystem + shell + MCP tools + skills. Use it to fan out isolated work \u2014 explore a folder, search, summarize a large file, draft something \u2014 without cluttering your own context. It returns its answer inline (no separate await step).
+    cliSubagentTasks = /* @__PURE__ */ new Map();
+    ASYNC_SPAWN_DESCRIPTION = `Start a background subagent for a self-contained task and return immediately.
 
-Give it a complete, standalone \`prompt\` (it does not see your conversation). Keep tasks focused; it can read/run things on the user's machine.`;
+The task runs in this CLI process. Use list_subagents to inspect status and await_subagents to collect results. The subagent is a fresh \`usable-chat\` agent running in the current working directory, with the same provider/config and local tools.`;
   }
 });
 
@@ -269592,7 +269767,7 @@ var init_tui_markdown = __esm({
 // src/cli/warp-agent.ts
 import { openSync, writeSync } from "node:fs";
 import { basename as basename9 } from "node:path";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 function isWarpAgentHost() {
   return !!process.env.WARP_CLI_AGENT_PROTOCOL_VERSION && process.platform !== "win32";
 }
@@ -269645,7 +269820,7 @@ var init_warp_agent = __esm({
     "use strict";
     WARP_AGENT_SLUG = "usable-chat";
     APP_NAME = "usable-chat";
-    sessionId = randomUUID6();
+    sessionId = randomUUID7();
   }
 });
 
@@ -269758,6 +269933,7 @@ async function launchTui(options2) {
   const ui2 = new TUI(terminal);
   const editor = new Editor(ui2, editorTheme, { paddingX: 1 });
   editor.focused = true;
+  const bangTools = createLocalTools();
   let items = [...initialHistory];
   let compactedPrefix = [];
   let busy = false;
@@ -269768,6 +269944,7 @@ async function launchTui(options2) {
   let exitArmed = false;
   let toolsExpanded = false;
   let abort = null;
+  let lastBangCommand = null;
   const extStatus = /* @__PURE__ */ new Map();
   let picker = null;
   const rebuildPicker = () => {
@@ -270021,6 +270198,56 @@ Edit it, then /verify-extension ${arg.trim()} to check it loads, /trust (project
   async function submit(raw) {
     const value = raw.trim();
     if (!value || busy) return;
+    if (value === "!!" || value.startsWith("!") && !value.startsWith("/")) {
+      const command = value === "!!" ? lastBangCommand : value.slice(1).trim();
+      if (!command) {
+        sys(value === "!!" ? "No previous shell command." : "Usage: ! <command>", "error");
+        return;
+      }
+      lastBangCommand = command;
+      busy = true;
+      push({ kind: "user", text: `! ${command}` });
+      const toolId = `bang-${Date.now()}`;
+      push({
+        kind: "tool",
+        id: toolId,
+        name: "bash",
+        args: short(JSON.stringify({ command })),
+        argsFull: prettyJson({ command }),
+        status: "running"
+      });
+      ui2.requestRender();
+      try {
+        const result = await bangTools.bash.execute({ command });
+        const error41 = result && typeof result === "object" && "error" in result ? String(result.error) : void 0;
+        items = items.map(
+          (it7) => it7.kind === "tool" && it7.id === toolId ? {
+            ...it7,
+            status: error41 ? "error" : "done",
+            result: error41 ? void 0 : previewValue(result),
+            error: error41
+          } : it7
+        );
+      } catch (err) {
+        items = items.map(
+          (it7) => it7.kind === "tool" && it7.id === toolId ? {
+            ...it7,
+            status: "error",
+            error: err instanceof Error ? err.message : String(err)
+          } : it7
+        );
+      } finally {
+        busy = false;
+        ui2.requestRender();
+        if (autoSubmit) {
+          setTimeout(() => {
+            teardown();
+            exit(0);
+          }, 25);
+        }
+      }
+      return;
+    }
     if (value.startsWith("/")) {
       const [cmd, ...rest] = value.slice(1).split(/\s+/);
       await runSlash(cmd.toLowerCase(), rest.join(" "));
@@ -270298,6 +270525,7 @@ var init_tui2 = __esm({
     "use strict";
     init_dist8();
     init_tui_select();
+    init_tools();
     init_tui_markdown();
     init_warp_agent();
     BANNER_LINES = [
@@ -270948,7 +271176,7 @@ init_tui_select();
 init_model_registry();
 
 // package.json
-var version2 = "1.152.1";
+var version2 = "1.154.0";
 
 // src/adapters/cli/model-catalog.ts
 init_codex_auth();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usabledev/usable-chat",
-  "version": "1.152.1",
+  "version": "1.154.0",
   "description": "usable-chat — terminal harness for usable-chat (headless + TUI)",
   "type": "module",
   "bin": {