@buildautomaton/cli 0.1.77 → 0.1.79

package/dist/index.js

@@ -3691,7 +3691,7 @@ var require_tree_kill = __commonJS({
   "../../node_modules/.pnpm/tree-kill@1.2.2/node_modules/tree-kill/index.js"(exports, module) {
     "use strict";
     var childProcess2 = __require("child_process");
-    var spawn11 = childProcess2.spawn;
+    var spawn12 = childProcess2.spawn;
     var exec = childProcess2.exec;
     module.exports = function(pid, signal, callback) {
       if (typeof signal === "function" && callback === void 0) {
@@ -3716,7 +3716,7 @@ var require_tree_kill = __commonJS({
           break;
         case "darwin":
           buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
-            return spawn11("pgrep", ["-P", parentPid]);
+            return spawn12("pgrep", ["-P", parentPid]);
           }, function() {
             killAll(tree, signal, callback);
           });
@@ -3728,7 +3728,7 @@ var require_tree_kill = __commonJS({
         //     break;
         default:
           buildProcessTree(pid, tree, pidsToProcess, function(parentPid) {
-            return spawn11("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+            return spawn12("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
           }, function() {
             killAll(tree, signal, callback);
           });
@@ -21909,31 +21909,31 @@ function handleWorkerOutMessage(message) {
     return;
   }
   if (message.type === "error") {
-    const pending2 = message.requestId != null ? pendingRequests.get(message.requestId) : void 0;
+    const pending3 = message.requestId != null ? pendingRequests.get(message.requestId) : void 0;
     maybeLogCodeNavCacheWorkerError(message.message);
-    if (pending2 != null) {
+    if (pending3 != null) {
       pendingRequests.delete(message.requestId);
       if (isCliImmediateShutdownRequested()) {
-        pending2.reject(new CliSqliteInterrupted());
+        pending3.reject(new CliSqliteInterrupted());
       } else {
-        pending2.reject(new Error(message.message));
+        pending3.reject(new Error(message.message));
       }
     }
     return;
   }
   if (!("requestId" in message)) return;
-  const pending = pendingRequests.get(message.requestId);
-  if (pending == null) return;
+  const pending2 = pendingRequests.get(message.requestId);
+  if (pending2 == null) return;
   pendingRequests.delete(message.requestId);
-  pending.resolve(message);
+  pending2.resolve(message);
 }
 function resetWorkerReadyState() {
   workerReady = false;
   workerReadyWaiters = [];
 }
 function rejectAllPendingRequests(error40) {
-  for (const [, pending] of pendingRequests) {
-    pending.reject(error40);
+  for (const [, pending2] of pendingRequests) {
+    pending2.reject(error40);
   }
   pendingRequests.clear();
 }
@@ -22966,14 +22966,14 @@ function legacyCliDiskMigrationIsPending() {
   return false;
 }
 function importCliSqliteLegacyDiskData(db, log2) {
-  const pending = legacyCliDiskMigrationIsPending();
-  if (pending && log2) {
+  const pending2 = legacyCliDiskMigrationIsPending();
+  if (pending2 && log2) {
     log2("Migrating legacy on-disk CLI data to SQLite\u2026");
   }
   archiveLegacyFileIndexJsonFiles();
   importLegacyAgentSessionsFromDisk(db);
   importLegacyPromptQueuesFromDisk(db);
-  if (pending && log2) {
+  if (pending2 && log2) {
     log2("Legacy on-disk CLI data migration finished.");
   }
 }
@@ -23060,7 +23060,11 @@ var init_migrate_cli_sqlite = __esm({
 });
 
 // src/sqlite/cli-database.ts
-var cliSqlite, safeCloseCliSqliteDatabase, closeAllCliSqliteConnections, openCliSqliteConnection, withCliSqliteSync, withCliSqlite, ensureCliSqliteInitialized;
+function closeAllCliSqliteConnections() {
+  legacyImportDoneForPath = null;
+  cliSqlite.closeAllConnections();
+}
+var legacyImportDoneForPath, cliSqlite, safeCloseCliSqliteDatabase, openCliSqliteConnection, withCliSqliteSync, withCliSqlite, ensureCliSqliteInitialized;
 var init_cli_database = __esm({
   "src/sqlite/cli-database.ts"() {
     "use strict";
@@ -23070,16 +23074,19 @@ var init_cli_database = __esm({
     init_import_cli_legacy_disk_data();
     init_migrate_cli_sqlite();
     init_sqlite_errors();
+    legacyImportDoneForPath = null;
     cliSqlite = createSqliteDatabaseAccess({
       getPath: getCliSqlitePath,
       ensureParentDir: ensureCliSqliteParentDir,
       migrate: migrateCliSqlite,
       afterOpen: (db, options) => {
+        const sqlitePath = getCliSqlitePath();
+        if (legacyImportDoneForPath === sqlitePath) return;
         importCliSqliteLegacyDiskData(db, options?.logLegacyMigration);
+        legacyImportDoneForPath = sqlitePath;
       }
     });
     safeCloseCliSqliteDatabase = cliSqlite.safeClose;
-    closeAllCliSqliteConnections = cliSqlite.closeAllConnections;
     openCliSqliteConnection = cliSqlite.openConnection;
     withCliSqliteSync = cliSqlite.withSync;
     withCliSqlite = cliSqlite.withAsync;
@@ -28212,9 +28219,9 @@ function createWsBridge(options) {
   return ws;
 }
 function sendWsMessage(ws, payload) {
-  if (ws.readyState === wrapper_default.OPEN) {
-    ws.send(JSON.stringify(payload));
-  }
+  if (ws.readyState !== wrapper_default.OPEN) return false;
+  ws.send(JSON.stringify(payload));
+  return true;
 }
 
 // src/files/cwd/index.ts
@@ -29345,6 +29352,31 @@ function getAgentModelFromAgentConfig(config2) {
 var HOUR_MS = 36e5;
 var DAY_MS = 24 * HOUR_MS;
 
+// ../types/src/hosts/skus.ts
+function defineHostSku(params) {
+  return structuredClone(params);
+}
+var FLY_LEGACY_HOST_SKU = defineHostSku({
+  id: "fly-shared-1x512-1gb",
+  provider: "fly",
+  compute: { cpus: 1, cpuKind: "shared" },
+  memory: { memoryMb: 512 },
+  storage: { storageGb: 1 },
+  monthlyPriceCents: 750
+});
+var FLY_DEFAULT_HOST_SKU = defineHostSku({
+  id: "fly-shared-1x1024-1gb",
+  provider: "fly",
+  compute: { cpus: 1, cpuKind: "shared" },
+  memory: { memoryMb: 1024 },
+  storage: { storageGb: 1 },
+  monthlyPriceCents: 1e3
+});
+var HOST_SKUS_BY_ID = {
+  [FLY_LEGACY_HOST_SKU.id]: FLY_LEGACY_HOST_SKU,
+  [FLY_DEFAULT_HOST_SKU.id]: FLY_DEFAULT_HOST_SKU
+};
+
 // ../types/src/bridges/agents/types.ts
 var INSTALLABLE_BRIDGE_AGENTS = [
   { value: "claude-code", label: "Anthropic Claude Code", tokenLabel: "Anthropic API key", tokenEnvVar: "ANTHROPIC_API_KEY" },
@@ -29458,11 +29490,11 @@ function createSdkStdioExtNotificationHandler(options) {
 
 // src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
 function awaitSdkStdioPermissionRequestHandshake(params) {
-  const { requestId, paramsRecord, pending, onRequest } = params;
+  const { requestId, paramsRecord, pending: pending2, onRequest } = params;
   return new Promise((resolve35) => {
-    pending.set(requestId, { resolve: resolve35, params: paramsRecord });
+    pending2.set(requestId, { resolve: resolve35, params: paramsRecord });
     if (onRequest == null) {
-      pending.delete(requestId);
+      pending2.delete(requestId);
       resolve35({ outcome: { outcome: "denied" } });
       return;
     }
@@ -29478,9 +29510,9 @@ function awaitSdkStdioPermissionRequestHandshake(params) {
 }
 
 // src/agents/acp/clients/sdk/sdk-stdio-permission-pending.ts
-function resolvePendingSdkStdioPermissionCancellations(pending) {
-  for (const [id, entry] of [...pending.entries()]) {
-    pending.delete(id);
+function resolvePendingSdkStdioPermissionCancellations(pending2) {
+  for (const [id, entry] of [...pending2.entries()]) {
+    pending2.delete(id);
     entry.resolve({ outcome: { outcome: "cancelled" } });
   }
 }
@@ -30606,7 +30638,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.77".length > 0 ? "0.1.77" : "0.0.0-dev";
+var CLI_VERSION = "0.1.79".length > 0 ? "0.1.79" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -33213,8 +33245,8 @@ function createCursorAcpSessionContext(options) {
 
 // src/agents/acp/clients/cursor/cancel-pending-cursor-permission-requests.ts
 function cancelPendingCursorPermissionRequests(pendingRequests2, respond) {
-  for (const [reqId, pending] of [...pendingRequests2.entries()]) {
-    if (pending.method === "session/request_permission") {
+  for (const [reqId, pending2] of [...pendingRequests2.entries()]) {
+    if (pending2.method === "session/request_permission") {
       respond(reqId, { outcome: { outcome: "cancelled" } });
       pendingRequests2.delete(reqId);
     }
@@ -33406,8 +33438,8 @@ function handleCursorIncomingPermissionRequest(id, method, msg, deps) {
 
 // src/agents/acp/clients/cursor/cursor-incoming-resolve-request.ts
 function resolveCursorIncomingRequest(pendingRequests2, respond, requestId, result) {
-  const pending = pendingRequests2.get(requestId);
-  const payload = pending?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending.params) : result;
+  const pending2 = pendingRequests2.get(requestId);
+  const payload = pending2?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending2.params) : result;
   respond(requestId, payload);
   pendingRequests2.delete(requestId);
 }
@@ -33545,25 +33577,25 @@ function createCursorJsonRpcInboundRespond(stdin) {
 
 // src/agents/acp/clients/cursor/cursor-json-rpc-outbound.ts
 function createCursorJsonRpcOutboundPending() {
-  const pending = /* @__PURE__ */ new Map();
+  const pending2 = /* @__PURE__ */ new Map();
   let nextId = 1;
   function allocateId() {
     return nextId++;
   }
   function register(id, waiter) {
-    pending.set(id, waiter);
+    pending2.set(id, waiter);
   }
   function settleResponse(id, msg) {
-    const waiter = pending.get(id);
+    const waiter = pending2.get(id);
     if (!waiter) return false;
-    pending.delete(id);
+    pending2.delete(id);
     if (msg.error) waiter.reject(msg.error);
     else waiter.resolve(msg.result);
     return true;
   }
   function rejectOnWriteError(id, err) {
-    const waiter = pending.get(id);
-    pending.delete(id);
+    const waiter = pending2.get(id);
+    pending2.delete(id);
     waiter?.reject(err);
   }
   return { allocateId, register, settleResponse, rejectOnWriteError };
@@ -33820,13 +33852,15 @@ import { existsSync as existsSync4, statSync } from "node:fs";
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import * as path27 from "node:path";
+var GIT_LOOKUP_TIMEOUT_MS = 2e3;
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
       cwd: path27.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
-      maxBuffer: 1024 * 1024
+      maxBuffer: 1024 * 1024,
+      timeout: GIT_LOOKUP_TIMEOUT_MS
     }).trim();
     return out ? path27.resolve(out) : null;
   } catch {
@@ -33838,6 +33872,7 @@ function getGitRepoRootSync(startDir) {
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
 import * as path28 from "node:path";
+var GIT_FILE_READ_TIMEOUT_MS = 2e3;
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
@@ -33899,7 +33934,8 @@ function readGitHeadBlob(sessionParentPath, displayPath) {
     return execFileSync4("git", ["show", `HEAD:${displayPath}`], {
       cwd: execCwd,
       encoding: "utf8",
-      maxBuffer: 50 * 1024 * 1024
+      maxBuffer: 50 * 1024 * 1024,
+      timeout: GIT_FILE_READ_TIMEOUT_MS
     });
   } catch {
     return "";
@@ -33907,6 +33943,7 @@ function readGitHeadBlob(sessionParentPath, displayPath) {
 }
 
 // src/agents/acp/session-file-change-path-kind.ts
+var GIT_PATH_KIND_TIMEOUT_MS = 2e3;
 function gitHeadPathObjectType(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(sessionParentPath);
@@ -33914,7 +33951,8 @@ function gitHeadPathObjectType(sessionParentPath, displayPath) {
   try {
     return execFileSync5("git", ["cat-file", "-t", `HEAD:${displayPath}`], {
       cwd: gitRoot,
-      encoding: "utf8"
+      encoding: "utf8",
+      timeout: GIT_PATH_KIND_TIMEOUT_MS
     }).trim();
   } catch {
     return null;
@@ -35022,23 +35060,30 @@ function augmentPromptResultAuthFields(agentType, errorText) {
 }
 
 // src/agents/planning/submit-planning-todos-for-turn.ts
+var PLANNING_TODO_SUBMIT_TIMEOUT_MS = 3e3;
 async function submitPlanningTodosForTurn(params) {
   const token = params.getCloudAccessToken();
   if (!token.trim()) return { ok: false, error: "Missing cloud access token" };
   const base = params.cloudApiBaseUrl.replace(/\/$/, "");
   const url2 = `${base}/internal/sessions/todos/submit`;
-  const res = await fetch(url2, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      sessionId: params.sessionId,
-      turnId: params.turnId,
-      items: params.items
-    })
-  });
+  let res;
+  try {
+    res = await fetch(url2, {
+      method: "POST",
+      signal: AbortSignal.timeout(PLANNING_TODO_SUBMIT_TIMEOUT_MS),
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        sessionId: params.sessionId,
+        turnId: params.turnId,
+        items: params.items
+      })
+    });
+  } catch (error40) {
+    return { ok: false, error: error40 instanceof Error ? error40.message : String(error40) };
+  }
   if (!res.ok) {
     const body = await res.json().catch(() => null);
     return { ok: false, error: body?.error ?? `Planning todo submit failed (${res.status})` };
@@ -36017,6 +36062,7 @@ async function resolveSendPromptImages(params) {
 }
 
 // src/agents/acp/prompts/send-prompt-to-agent.ts
+var SLOW_ACP_PROMPT_MS = 5e3;
 async function sendPromptToAgent(options) {
   const {
     handle,
@@ -36063,7 +36109,12 @@ async function sendPromptToAgent(options) {
       sendResult(imagesResolved.errorResult);
       return;
     }
+    const promptStartedAt = Date.now();
     const result = await handle.sendPrompt(prepared.agentPromptText, imagesResolved.sendOpts);
+    const promptDurationMs = Date.now() - promptStartedAt;
+    if (promptDurationMs >= SLOW_ACP_PROMPT_MS) {
+      log2(`[Agent] ACP session/prompt completed after ${promptDurationMs}ms.`);
+    }
     await finalizeAndSendPromptResult({
       result,
       sessionId,
@@ -38432,11 +38483,11 @@ function tryConsumeBinaryProxyBody(raw, deps) {
   if (!PROXY_ID_RE.test(id)) return false;
   const body = raw.slice(PROXY_ID_BYTES);
   const bodyBytes = body.length > 0 ? new Uint8Array(body) : new Uint8Array(0);
-  const pending = deps.pendingProxyBody.get(id);
-  if (pending) {
+  const pending2 = deps.pendingProxyBody.get(id);
+  if (pending2) {
     deps.pendingProxyBody.delete(id);
     deps.startStreamingProxy({
-      ...pending.pr,
+      ...pending2.pr,
       body: bodyBytes.length > 0 ? bodyBytes : void 0
     });
     return true;
@@ -38829,9 +38880,9 @@ function processHeartbeatAck(params) {
   if (awaitingSeq === null) return { awaitingSeq, missed: 0 };
   if (!Number.isFinite(seq)) return { awaitingSeq, missed: 0 };
   const ack = Math.trunc(seq);
-  const pending = awaitingSeq;
-  if (ack < pending) return { awaitingSeq, missed: 0 };
-  if (ack === pending) {
+  const pending2 = awaitingSeq;
+  if (ack < pending2) return { awaitingSeq, missed: 0 };
+  if (ack === pending2) {
     recordRtt(Date.now() - sentAtMs);
   }
   return { awaitingSeq: null, missed: 0 };
@@ -46479,9 +46530,13 @@ import * as fs49 from "node:fs";
 import * as path70 from "node:path";
 
 // src/git/snapshot/git.ts
+var SNAPSHOT_GIT_TIMEOUT_MS = 5e3;
 async function gitStashCreate(repoRoot, log2) {
   try {
-    const { stdout } = await execGitFile(["stash", "create"], { cwd: repoRoot });
+    const { stdout } = await execGitFile(["stash", "create"], {
+      cwd: repoRoot,
+      timeout: SNAPSHOT_GIT_TIMEOUT_MS
+    });
     return stdout.trim();
   } catch (e) {
     log2(
@@ -46492,7 +46547,10 @@ async function gitStashCreate(repoRoot, log2) {
 }
 async function gitUntrackedPaths(repoRoot, log2) {
   try {
-    const { stdout } = await execGitFile(["ls-files", "--others", "--exclude-standard"], { cwd: repoRoot });
+    const { stdout } = await execGitFile(["ls-files", "--others", "--exclude-standard"], {
+      cwd: repoRoot,
+      timeout: SNAPSHOT_GIT_TIMEOUT_MS
+    });
     return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
   } catch (e) {
     log2(
@@ -49177,28 +49235,78 @@ async function startPromptQueueRuns(entries, deps) {
 }
 
 // src/prompt-turn-queue/runner/apply-prompt-queue-state-from-server.ts
+var SLOW_QUEUE_SYNC_MS = 2e3;
 async function applyPromptQueueStateFromServer(msg, deps) {
   const raw = msg.queues;
   if (!raw || typeof raw !== "object") return;
+  const startedAt = Date.now();
   const entries = promptQueueSnapshotEntries(raw);
   await persistPromptQueueSnapshot(entries);
   await handlePromptQueueCancellations(entries, deps);
   const started = await startPromptQueueRuns(entries, deps);
   await dispatchStartedPromptQueueRuns(entries, started, deps);
+  const durationMs = Date.now() - startedAt;
+  if (durationMs >= SLOW_QUEUE_SYNC_MS) {
+    deps.log(`[Queue] Queue state sync and dispatch took ${durationMs}ms.`);
+  }
+}
+
+// src/agents/acp/from-bridge/pending-prompt-results.ts
+var pending = [];
+function enqueuePendingPromptResult(message) {
+  const runId = typeof message.runId === "string" ? message.runId : "";
+  if (runId) {
+    const idx = pending.findIndex((m) => m.runId === runId);
+    if (idx >= 0) pending.splice(idx, 1);
+  }
+  pending.push(message);
+}
+function flushPendingPromptResults(getWs, encrypt) {
+  if (pending.length === 0) return;
+  const ws = getWs();
+  if (!ws || ws.readyState !== wrapper_default.OPEN) return;
+  const still = [];
+  for (const message of pending) {
+    const wire = encrypt ? encrypt(message) : message;
+    if (!sendWsMessage(ws, wire)) still.push(message);
+  }
+  pending.length = 0;
+  pending.push(...still);
+}
+
+// src/agents/acp/from-bridge/send-session-update-wire.ts
+function sendSessionUpdateWire(getWs, payload, opts) {
+  const s = getWs();
+  if (!s || s.readyState !== wrapper_default.OPEN) {
+    opts.log("[Bridge service] Session update not sent: not connected to the bridge.");
+    return;
+  }
+  const p = payload;
+  const wire = p.type === "session_update" && opts.e2ee ? opts.e2ee.encryptFields(payload, ["payload"]) : p.type === "session_file_change" && opts.e2ee ? opts.e2ee.encryptFields(payload, [
+    "path",
+    "oldText",
+    "newText",
+    "patchContent",
+    "isDirectory",
+    "directoryRemoved"
+  ]) : payload;
+  sendWsMessage(s, wire);
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-wiring.ts
 function createBridgePromptSenders(deps, getWs) {
   const sendBridgeMessage = (message, encryptedFields = []) => {
     const s = getWs();
-    if (!s) return false;
+    if (!s || s.readyState !== wrapper_default.OPEN) return false;
     const wire = deps.e2ee && encryptedFields.length > 0 ? deps.e2ee.encryptFields(message, encryptedFields) : message;
-    sendWsMessage(s, wire);
-    return true;
+    return sendWsMessage(s, wire);
   };
   const sendResult = (result) => {
-    const encryptedFields = result.type === "prompt_result" ? ["output", "error"] : [];
-    sendBridgeMessage(result, encryptedFields);
+    const sent = sendBridgeMessage(result, result.type === "prompt_result" ? ["output", "error"] : []);
+    if (!sent && result.type === "prompt_result") {
+      enqueuePendingPromptResult(result);
+      deps.log("[Bridge service] prompt_result deferred until bridge reconnect.");
+    }
     if (result.type === "prompt_result") {
       const pr = result;
       const cancelled = pr.stopReason === "cancelled";
@@ -49211,24 +49319,11 @@ function createBridgePromptSenders(deps, getWs) {
       });
     }
   };
-  const sendSessionUpdate = (payload) => {
-    const s = getWs();
-    if (!s) {
-      deps.log("[Bridge service] Session update not sent: not connected to the bridge.");
-      return;
-    }
-    const p = payload;
-    const wire = p.type === "session_update" && deps.e2ee ? deps.e2ee.encryptFields(payload, ["payload"]) : p.type === "session_file_change" && deps.e2ee ? deps.e2ee.encryptFields(payload, [
-      "path",
-      "oldText",
-      "newText",
-      "patchContent",
-      "isDirectory",
-      "directoryRemoved"
-    ]) : payload;
-    sendWsMessage(s, wire);
+  return {
+    sendBridgeMessage,
+    sendResult,
+    sendSessionUpdate: (payload) => sendSessionUpdateWire(getWs, payload, { e2ee: deps.e2ee, log: deps.log })
   };
-  return { sendBridgeMessage, sendResult, sendSessionUpdate };
 }
 
 // src/agents/acp/from-bridge/handle-bridge-prompt/parse-bridge-attachments.ts
@@ -49261,59 +49356,93 @@ function parseWorktreeBaseBranches(msg) {
   return Object.keys(out).length > 0 ? out : void 0;
 }
 
-// src/agents/acp/from-bridge/bridge-prompt-preamble.ts
+// src/agents/acp/from-bridge/parse-follow-up-prompt-fields.ts
+function parseFollowUpFieldsFromPromptMessage(msg) {
+  const value = msg.followUpCatalogPromptId;
+  return {
+    followUpCatalogPromptId: typeof value === "string" && value.trim() !== "" ? value.trim() : null
+  };
+}
+
+// src/agents/acp/from-bridge/prepare-bridge-prompt-git-state.ts
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
+
+// src/agents/acp/from-bridge/git-state-preparation-timeout.ts
+async function awaitGitStatePreparation(options) {
+  const { label, timeoutMs, work, fallback, log: log2 } = options;
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((resolve35) => {
+        timer = setTimeout(() => {
+          log2(`[Agent] ${label} exceeded ${timeoutMs}ms; continuing without it.`);
+          resolve35(fallback);
+        }, timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/agents/acp/from-bridge/prepare-bridge-prompt-git-state.ts
 var execFileAsync7 = promisify9(execFile8);
+var GIT_STATE_DISCOVERY_TIMEOUT_MS = 2e3;
 async function readGitBranch(cwd) {
   try {
-    const { stdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
-    const b = stdout.trim();
-    return b || null;
+    const { stdout } = await execFileAsync7("git", ["branch", "--show-current"], {
+      cwd,
+      maxBuffer: 64 * 1024,
+      timeout: GIT_STATE_DISCOVERY_TIMEOUT_MS
+    });
+    return stdout.trim() || null;
   } catch {
     return null;
   }
 }
-async function runBridgePromptPreamble(params) {
+async function prepareBridgePromptGitState(params) {
   const { getWs, log: log2, sessionWorktreeManager, sessionId, runId, effectiveCwd } = params;
-  const s = getWs();
-  const repoCheckoutPaths = await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sessionId);
+  const repoCheckoutPaths = await awaitGitStatePreparation({
+    label: "Session worktree discovery",
+    timeoutMs: GIT_STATE_DISCOVERY_TIMEOUT_MS,
+    work: sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sessionId),
+    fallback: void 0,
+    log: log2
+  });
   const repoRoots = await resolveSnapshotRepoRoots({
     worktreePaths: repoCheckoutPaths,
     fallbackCwd: effectiveCwd,
     sessionId: sessionId?.trim() || void 0,
     log: log2
   });
-  if (s && sessionId) {
-    const usesWt = sessionWorktreeManager.usesWorktreeSession(sessionId);
-    const cliGitBranch = repoRoots.length > 0 ? await readGitBranch(effectiveCwd) : null;
-    const isolatedSessionParentPath = sessionWorktreeManager.getIsolatedSessionParentPathForSession(sessionId);
-    sendWsMessage(s, {
+  const socket = getWs();
+  if (socket && sessionId) {
+    const usesWorktree = sessionWorktreeManager.usesWorktreeSession(sessionId);
+    sendWsMessage(socket, {
       type: "session_git_context_report",
       sessionId,
-      cliGitBranch,
-      agentUsesWorktree: usesWt,
-      sessionParent: usesWt ? "worktrees_root" : "bridge_root",
-      sessionParentPath: usesWt ? isolatedSessionParentPath ?? effectiveCwd : getBridgeRoot()
+      cliGitBranch: repoRoots.length > 0 ? await readGitBranch(effectiveCwd) : null,
+      agentUsesWorktree: usesWorktree,
+      sessionParent: usesWorktree ? "worktrees_root" : "bridge_root",
+      sessionParentPath: usesWorktree ? sessionWorktreeManager.getIsolatedSessionParentPathForSession(sessionId) ?? effectiveCwd : getBridgeRoot()
     });
   }
-  if (s && sessionId && runId) {
-    const cap = repoRoots.length > 0 ? await capturePreTurnSnapshot({ runId, repoRoots, agentCwd: effectiveCwd, log: log2 }) : { ok: false, error: "No git repos" };
-    sendWsMessage(s, {
+  if (socket && sessionId && runId) {
+    const snapshot = repoRoots.length > 0 ? await capturePreTurnSnapshot({ runId, repoRoots, agentCwd: effectiveCwd, log: log2 }) : { ok: false };
+    sendWsMessage(socket, {
       type: "pre_turn_snapshot_report",
       sessionId,
       turnId: runId,
-      captured: cap.ok
+      captured: snapshot.ok
     });
   }
 }
-function parseFollowUpFieldsFromPromptMessage(msg) {
-  const followUpCatalogPromptId = typeof msg.followUpCatalogPromptId === "string" && msg.followUpCatalogPromptId.trim() !== "" ? msg.followUpCatalogPromptId.trim() : null;
-  return { followUpCatalogPromptId };
-}
 
-// src/agents/acp/from-bridge/handle-bridge-prompt/run-preamble-and-prompt.ts
-async function runPreambleAndPrompt(params) {
+// src/agents/acp/from-bridge/handle-bridge-prompt/prepare-git-state-and-run-prompt.ts
+async function prepareGitStateAndRunPrompt(params) {
   const {
     deps,
     msg,
@@ -49332,7 +49461,7 @@ async function runPreambleAndPrompt(params) {
     senders: { sendResult, sendSessionUpdate }
   } = params;
   const effectiveCwd = resolveSessionParentPathForAgentProcess(resolvedCwd);
-  await runBridgePromptPreamble({
+  await prepareBridgePromptGitState({
     getWs,
     log: log2,
     sessionWorktreeManager,
@@ -49403,7 +49532,7 @@ function handleBridgePrompt(msg, deps) {
     sessionParentPath,
     ...worktreeBaseBranches ? { worktreeBaseBranches } : {}
   }).then(
-    (cwd) => runPreambleAndPrompt({
+    (cwd) => prepareGitStateAndRunPrompt({
       deps,
       msg,
       getWs,
@@ -49422,7 +49551,7 @@ function handleBridgePrompt(msg, deps) {
     })
   ).catch((err) => {
     log2(`[Agent] Session parent path resolve failed: ${err instanceof Error ? err.message : String(err)}`);
-    void runPreambleAndPrompt({
+    void prepareGitStateAndRunPrompt({
       deps,
       msg,
       getWs,
@@ -49904,25 +50033,59 @@ var handleInstallSkillsMessage = (msg, deps) => {
   })();
 };
 
-// src/agents/install/commands/run-npm-global-install.ts
-import { execFile as execFile9 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
-
-// src/agents/install/format-command-output.ts
-function formatCommandOutput(stdout, stderr) {
-  const parts = [String(stdout ?? "").trimEnd(), String(stderr ?? "").trimEnd()].filter(Boolean);
-  return parts.join("\n");
+// src/agents/install/run-streaming-command.ts
+import { spawn as spawn11 } from "node:child_process";
+import * as readline3 from "node:readline";
+function runStreamingCommand(command, args, options) {
+  return new Promise((resolve35, reject) => {
+    const child = spawn11(command, args, {
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let settled = false;
+    const timer = options.timeoutMs != null ? setTimeout(() => {
+      child.kill("SIGKILL");
+      if (!settled) {
+        settled = true;
+        reject(new Error(`Command timed out after ${options.timeoutMs}ms`));
+      }
+    }, options.timeoutMs) : null;
+    const onLine = (line) => {
+      if (line.length > 0) options.onLine?.(line);
+    };
+    if (child.stdout) {
+      readline3.createInterface({ input: child.stdout, crlfDelay: Infinity }).on("line", onLine);
+    }
+    if (child.stderr) {
+      readline3.createInterface({ input: child.stderr, crlfDelay: Infinity }).on("line", onLine);
+    }
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+    child.on("close", (code, signal) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        resolve35({ code, signal });
+      }
+    });
+  });
 }
 
 // src/agents/install/commands/run-npm-global-install.ts
-var execFileAsync8 = promisify10(execFile9);
-async function runNpmGlobalInstall(packageName, env, timeoutMs = 3e5) {
-  const { stdout, stderr } = await execFileAsync8("npm", ["install", "-g", packageName], {
-    timeout: timeoutMs,
+async function runNpmGlobalInstall(packageName, env, options) {
+  const result = await runStreamingCommand("npm", ["install", "-g", packageName], {
     env: bridgeAgentPathEnv(env),
-    maxBuffer: 10 * 1024 * 1024
+    timeoutMs: options?.timeoutMs ?? 3e5,
+    onLine: options?.onLine
   });
-  return formatCommandOutput(stdout, stderr);
+  if (result.code !== 0) {
+    throw new Error(`npm install -g ${packageName} failed (exit ${result.code ?? "signal"})`);
+  }
 }
 
 // src/agents/install/commands/claude-code.ts
@@ -49930,11 +50093,12 @@ var claudeCodeInstallCommand = {
   agentType: "claude-code",
   detectCommand: "claude",
   async install(ctx) {
-    const logOutput = await runNpmGlobalInstall("@anthropic-ai/claude-code", {
-      ...ctx.env,
-      ANTHROPIC_API_KEY: ctx.authToken
-    });
-    ctx.onProgress?.("Installing Anthropic Claude Code", logOutput || void 0);
+    ctx.onProgress?.("Installing Anthropic Claude Code");
+    await runNpmGlobalInstall(
+      "@anthropic-ai/claude-code",
+      { ...ctx.env, ANTHROPIC_API_KEY: ctx.authToken },
+      { onLine: (line) => ctx.onProgress?.("Installing Anthropic Claude Code", line) }
+    );
   }
 };
 
@@ -49943,34 +50107,34 @@ var codexAcpInstallCommand = {
   agentType: "codex-acp",
   detectCommand: "codex",
   async install(ctx) {
-    const logOutput = await runNpmGlobalInstall("@openai/codex", {
-      ...ctx.env,
-      OPENAI_API_KEY: ctx.authToken
-    });
-    ctx.onProgress?.("Installing Codex", logOutput || void 0);
+    ctx.onProgress?.("Installing Codex");
+    await runNpmGlobalInstall(
+      "@openai/codex",
+      { ...ctx.env, OPENAI_API_KEY: ctx.authToken },
+      { onLine: (line) => ctx.onProgress?.("Installing Codex", line) }
+    );
   }
 };
 
 // src/agents/install/commands/cursor-cli.ts
-import { execFile as execFile10 } from "node:child_process";
-import { promisify as promisify11 } from "node:util";
-var execFileAsync9 = promisify11(execFile10);
 var cursorCliInstallCommand = {
   agentType: "cursor-cli",
   detectCommand: "agent",
   alternateDetectCommands: ["cursor-agent"],
   async install(ctx) {
-    const { stdout, stderr } = await execFileAsync9(
+    ctx.onProgress?.("Installing Cursor CLI");
+    const result = await runStreamingCommand(
       "bash",
       ["-lc", "curl -fsSL https://cursor.com/install | bash"],
       {
-        timeout: 3e5,
+        timeoutMs: 3e5,
         env: { ...bridgeAgentPathEnv(ctx.env), CURSOR_API_KEY: ctx.authToken },
-        maxBuffer: 10 * 1024 * 1024
+        onLine: (line) => ctx.onProgress?.("Installing Cursor CLI", line)
       }
     );
-    const logOutput = formatCommandOutput(stdout, stderr);
-    ctx.onProgress?.("Installing Cursor CLI", logOutput || void 0);
+    if (result.code !== 0) {
+      throw new Error(`Cursor CLI install failed (exit ${result.code ?? "signal"})`);
+    }
   }
 };
 
@@ -49979,11 +50143,12 @@ var opencodeInstallCommand = {
   agentType: "opencode",
   detectCommand: "opencode",
   async install(ctx) {
-    const logOutput = await runNpmGlobalInstall("opencode-ai", {
-      ...ctx.env,
-      OPENCODE_API_KEY: ctx.authToken
-    });
-    ctx.onProgress?.("Installing OpenCode", logOutput || void 0);
+    ctx.onProgress?.("Installing OpenCode");
+    await runNpmGlobalInstall(
+      "opencode-ai",
+      { ...ctx.env, OPENCODE_API_KEY: ctx.authToken },
+      { onLine: (line) => ctx.onProgress?.("Installing OpenCode", line) }
+    );
   }
 };
 
@@ -50044,25 +50209,47 @@ var handleInstallAgentMessage = (msg, deps) => {
   if (!processId || !agentId || !tokenId || !agentType || !authToken) return;
   void (async () => {
     const socket = deps.getWs();
-    const report = (step, message, logOutput) => {
-      if (socket) {
-        sendWsMessage(socket, {
-          type: "install_agent_progress",
-          processId,
-          agentId,
-          tokenId,
-          agentType,
-          step,
-          message,
-          ...logOutput ? { logOutput } : {}
-        });
+    let pendingLines = [];
+    let flushTimer = null;
+    const sendProgress = (message, logOutput) => {
+      if (!socket) return;
+      sendWsMessage(socket, {
+        type: "install_agent_progress",
+        processId,
+        agentId,
+        tokenId,
+        agentType,
+        step: "agent_install_package",
+        message,
+        ...logOutput ? { logOutput } : {}
+      });
+    };
+    const flushLines = (message) => {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
       }
+      if (pendingLines.length === 0) return;
+      const logOutput = pendingLines.join("\n");
+      pendingLines = [];
+      sendProgress(message, logOutput);
     };
     const result = await installLocalAgentOnBridge({
       agentType,
       authToken,
-      onProgress: (message, logOutput) => report("agent_install_package", message, logOutput)
+      onProgress: (message, logOutput) => {
+        if (logOutput == null) {
+          flushLines(message);
+          sendProgress(message);
+          return;
+        }
+        pendingLines.push(logOutput);
+        if (!flushTimer) {
+          flushTimer = setTimeout(() => flushLines(message), 100);
+        }
+      }
     });
+    flushLines("Installing agent packages on the bridge machine.");
     if (socket) {
       sendWsMessage(socket, {
         type: "install_agent_result",
@@ -50074,9 +50261,7 @@ var handleInstallAgentMessage = (msg, deps) => {
         error: result.error
       });
     }
-    if (result.success) {
-      await deps.reportAutoDetectedAgents?.();
-    }
+    if (result.success) await deps.reportAutoDetectedAgents?.();
     if (!result.success) {
       deps.log(`[Bridge service] Install agent failed: ${result.error ?? "unknown"}`);
     }
@@ -50661,6 +50846,10 @@ function createMainBridgeOpenHandler(params) {
     if (socket) {
       sendBridgeIdentify(socket, { identifyReportedPaths, e2ee });
       reportGitRepos(getWs, logFn);
+      flushPendingPromptResults(
+        getWs,
+        (message) => e2ee ? e2ee.encryptFields(message, ["output", "error"]) : message
+      );
       try {
         onBridgeSocketOpen?.();
       } catch {
@@ -50805,7 +50994,7 @@ async function createBridgeConnection(options) {
 }
 
 // src/e2e-certificates/key-command.ts
-import * as readline3 from "node:readline";
+import * as readline4 from "node:readline";
 function installE2eCertificateKeyCommand({
   log: log2,
   onOpenCertificate,
@@ -50816,7 +51005,7 @@ function installE2eCertificateKeyCommand({
     return () => {
     };
   }
-  readline3.emitKeypressEvents(process.stdin);
+  readline4.emitKeypressEvents(process.stdin);
   process.stdin.setRawMode(true);
   process.stdin.resume();
   const onKeypress = (str, key) => {