@rallycry/conveyor-agent 10.0.5 → 10.1.0

package/dist/{chunk-S72TAMGA.js → chunk-DAHP6JPD.js}

@@ -186,6 +186,7 @@ var AgentConnection = class _AgentConnection {
   apiKeyUpdateCallback = null;
   pullBranchCallback = null;
   finalizeSnapshotCallback = null;
+  runStartCommandCallback = null;
   earlyPullBranches = [];
   // PTY relay (S5 terminal). Single-slot callbacks, set per PtySession run.
   ptyInputCallback = null;
@@ -211,6 +212,20 @@ var AgentConnection = class _AgentConnection {
   // the model to retry the tool, which is the safe place to decide idempotency.
   static CALL_CONNECT_WAIT_MS = 2e4;
   static CALL_ACK_TIMEOUT_MS = 3e4;
+  // ── Proactive socket recycle ───────────────────────────────────────────
+  // Cloud Run severs every WebSocket at its request timeout (3600s is the
+  // platform ceiling), so a socket that lives past ~60 minutes is killed at a
+  // random moment — historically mid-tool-call, which let the spawned CLI
+  // abandon its MCP session. Recycle the transport at a QUIET moment (no
+  // in-flight RPC) before the platform deadline instead: an engine-level close
+  // looks like a transport drop, so Socket.IO's auto-reconnect and the
+  // io "reconnect" → reconnectToSession() recovery path run unchanged. Jitter
+  // keeps a fleet of pods from recycling in one thundering herd.
+  static SOCKET_RECYCLE_BASE_MS = 52 * 60 * 1e3;
+  static SOCKET_RECYCLE_JITTER_MS = 4 * 60 * 1e3;
+  static SOCKET_RECYCLE_BUSY_POLL_MS = 15e3;
+  recycleTimer = null;
+  pendingCalls = 0;
   async call(method, payload) {
     const socket = this.socket;
     if (!socket) {
@@ -218,10 +233,46 @@ var AgentConnection = class _AgentConnection {
         `Not connected (method: ${String(method)}, session: ${this.config.sessionId})`
       );
     }
-    if (!socket.connected) {
-      await this.waitForConnected(socket, _AgentConnection.CALL_CONNECT_WAIT_MS, String(method));
+    this.pendingCalls++;
+    try {
+      if (!socket.connected) {
+        await this.waitForConnected(socket, _AgentConnection.CALL_CONNECT_WAIT_MS, String(method));
+      }
+      return await this.emitWithAck(socket, method, payload);
+    } finally {
+      this.pendingCalls--;
+    }
+  }
+  /** (Re)arm the recycle timer — called on every successful (re)connect. */
+  scheduleSocketRecycle() {
+    this.clearSocketRecycle();
+    const delay = _AgentConnection.SOCKET_RECYCLE_BASE_MS + Math.random() * _AgentConnection.SOCKET_RECYCLE_JITTER_MS;
+    this.armRecycleTimer(delay);
+  }
+  clearSocketRecycle() {
+    if (this.recycleTimer) {
+      clearTimeout(this.recycleTimer);
+      this.recycleTimer = null;
+    }
+  }
+  armRecycleTimer(delay) {
+    this.recycleTimer = setTimeout(() => {
+      this.recycleTimer = null;
+      this.attemptSocketRecycle();
+    }, delay);
+    this.recycleTimer.unref?.();
+  }
+  attemptSocketRecycle() {
+    const socket = this.socket;
+    if (!socket?.connected) return;
+    if (this.pendingCalls > 0) {
+      this.armRecycleTimer(_AgentConnection.SOCKET_RECYCLE_BUSY_POLL_MS);
+      return;
     }
-    return await this.emitWithAck(socket, method, payload);
+    process.stderr.write(
+      "[conveyor-agent] Recycling socket ahead of the platform request timeout\n"
+    );
+    socket.io.engine?.close?.();
   }
   /** Resolve once `socket` reports connected, or reject after `timeoutMs`. */
   waitForConnected(socket, timeoutMs, method) {
@@ -343,6 +394,9 @@ var AgentConnection = class _AgentConnection {
       this.socket.on("session:finalizeSnapshot", () => {
         this.finalizeSnapshotCallback?.();
       });
+      this.socket.on("session:runStartCommand", () => {
+        this.runStartCommandCallback?.();
+      });
       this.socket.on("pty:input", (data) => {
         if (data.sessionId && data.sessionId !== this.config.sessionId) return;
         this.ptyInputCallback?.(data.data);
@@ -353,6 +407,7 @@ var AgentConnection = class _AgentConnection {
       });
       this.socket.on("connect", () => {
         process.stderr.write("[conveyor-agent] Socket connected\n");
+        this.scheduleSocketRecycle();
         if (!settled) {
           settled = true;
           resolve();
@@ -400,6 +455,7 @@ var AgentConnection = class _AgentConnection {
   }
   disconnect() {
     this.stopProactiveTokenRefresh();
+    this.clearSocketRecycle();
     void this.flushEvents();
     if (this.socket) {
       this.socket.io.reconnection(false);
@@ -568,6 +624,9 @@ var AgentConnection = class _AgentConnection {
   onFinalizeSnapshot(callback) {
     this.finalizeSnapshotCallback = callback;
   }
+  onRunStartCommand(callback) {
+    this.runStartCommandCallback = callback;
+  }
   // ── PTY relay (S5 Connected-TUI terminal) ──────────────────────────
   /**
    * Forward a raw chunk of terminal output to the S2 relay (fire-and-forget).
@@ -583,6 +642,17 @@ var AgentConnection = class _AgentConnection {
     }).catch(() => {
     });
   }
+  /**
+   * Report that the interactive CLI process for this session has died and no
+   * respawn is imminent (fire-and-forget). The server clears the scrollback
+   * ring and broadcasts pty:ended so clients hide the Connected-TUI tab. Old
+   * servers that don't know the method reject harmlessly.
+   */
+  sendPtyEnded() {
+    if (!this.socket) return;
+    void this.call("ptyEnded", { sessionId: this.config.sessionId }).catch(() => {
+    });
+  }
   /** Subscribe to relayed keystrokes. Returns an unsubscribe fn. */
   onPtyInput(handler) {
     this.ptyInputCallback = handler;
@@ -2486,6 +2556,9 @@ var GetUiCliHistoryRequestSchema = z.object({
 var GetActivePtySessionRequestSchema = z.object({
   taskId: z.string()
 });
+var ListActivePtySessionsRequestSchema = z.object({
+  taskId: z.string()
+});
 var SendSoftStopRequestSchema = z.object({
   taskId: z.string()
 });
@@ -2548,6 +2621,9 @@ var PtyOutputRequestSchema = z.object({
   cols: z.number().int().positive().max(PTY_MAX_DIMENSION).optional(),
   rows: z.number().int().positive().max(PTY_MAX_DIMENSION).optional()
 });
+var PtyEndedRequestSchema = z.object({
+  sessionId: z.string()
+});
 var PtyInputRequestSchema = z.object({
   sessionId: z.string(),
   data: z.string().max(PTY_FRAME_MAX_CHARS)
@@ -2866,6 +2942,7 @@ var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
 
 // src/runner/mode-controller.ts
+var FRESH_AUTO_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
 var ModeController = class {
   _mode;
   _hasExitedPlanMode = false;
@@ -2949,12 +3026,25 @@ var ModeController = class {
     }
     return this._mode;
   }
-  /** Check if auto-mode can bypass planning (task already has plan + properties) */
+  /**
+   * A FRESH auto task runs the read-only plan turn first (`--permission-mode plan`):
+   * resolveInitialMode leaves it in `auto` with `_hasExitedPlanMode = false`, and
+   * once the agent finishes it calls ExitPlanMode → building. Only tasks that have
+   * already progressed past the fresh stage bypass planning and build immediately
+   * with `--dangerously-skip-permissions`:
+   *
+   * - a build already underway (status past `Planning`/`Open`),
+   * - a PR already open (safety net if status lags),
+   * - a release (booted `InProgress`), or
+   * - a pod restart mid-build (DB `agentMode` stays `"auto"` but status advanced).
+   *
+   * Runtime Build-after-Discovery never reaches this gate as `auto` — the server's
+   * `resolveModeToSend` rewrites it to `"building"` for any non-`Planning` task.
+   */
   canBypassPlanning(context) {
     if (this._mode !== "auto") return false;
-    if (context.status !== "Planning") return true;
-    if (context.plan?.trim() && context.storyPointId) return true;
-    return false;
+    if (!FRESH_AUTO_STATUSES.has(context.status)) return true;
+    return !!context.githubPRUrl;
   }
   // ── Mode transitions ───────────────────────────────────────────────
   /** Handle mode change from server */
@@ -3017,7 +3107,8 @@ var DEFAULT_LIFECYCLE_CONFIG = {
   dormantTimeoutMs: 60 * 60 * 1e3,
   heartbeatIntervalMs: 3e4,
   tokenRefreshIntervalMs: 45 * 60 * 1e3,
-  gitFlushIntervalMs: 2 * 60 * 1e3
+  gitFlushIntervalMs: 2 * 60 * 1e3,
+  usageSampleIntervalMs: 5 * 60 * 1e3
 };
 var Lifecycle = class {
   config;
@@ -3028,6 +3119,7 @@ var Lifecycle = class {
   idleCheckInterval = null;
   dormantTimer = null;
   gitFlushTimer = null;
+  usageSampleTimer = null;
   constructor(config, callbacks) {
     this.config = config;
     this.callbacks = callbacks;
@@ -3073,6 +3165,21 @@ var Lifecycle = class {
       this.gitFlushTimer = null;
     }
   }
+  // ── Claude key usage sampling ─────────────────────────────────────
+  startUsageSample() {
+    this.stopUsageSample();
+    if (this.config.usageSampleIntervalMs <= 0) return;
+    this.callbacks.onUsageSample();
+    this.usageSampleTimer = setInterval(() => {
+      this.callbacks.onUsageSample();
+    }, this.config.usageSampleIntervalMs);
+  }
+  stopUsageSample() {
+    if (this.usageSampleTimer) {
+      clearInterval(this.usageSampleTimer);
+      this.usageSampleTimer = null;
+    }
+  }
   // ── Idle timer ─────────────────────────────────────────────────────
   startIdleTimer() {
     this.clearIdleTimers();
@@ -3109,6 +3216,7 @@ var Lifecycle = class {
     this.stopHeartbeat();
     this.stopTokenRefresh();
     this.stopGitFlush();
+    this.stopUsageSample();
     this.clearIdleTimers();
     this.cancelDormantTimer();
   }
@@ -3168,7 +3276,7 @@ var ClaudeCodeHarness = class {
 };
 
 // src/harness/pty/session.ts
-import { mkdtemp as mkdtemp2, mkdir as mkdir2, rm as rm4, stat as stat3 } from "fs/promises";
+import { mkdtemp as mkdtemp2, mkdir as mkdir2, rm as rm4 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join4, dirname } from "path";
 
@@ -3549,6 +3657,14 @@ function buildSpawnArgs(input) {
   }
   return args;
 }
+function spawnOptionsFingerprint(input) {
+  return JSON.stringify([
+    input.model,
+    input.permissionMode,
+    input.appendSystemPrompt ?? "",
+    input.cwd
+  ]);
+}
 var ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`, "g");
 function cleanTerminalOutput(raw, maxChars = 1200) {
   const noAnsi = raw.replace(ANSI_CSI, "");
@@ -3641,6 +3757,7 @@ import { join as join3 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
 // src/harness/pty/mcp-server.ts
 var PtyMcpServer = class {
@@ -3662,6 +3779,7 @@ var PtyMcpServer = class {
 
 // src/harness/pty/tool-server.ts
 var LOOPBACK = "127.0.0.1";
+var MAX_SESSIONS = 16;
 var PtyToolServer = class {
   constructor(name, tools) {
     this.name = name;
@@ -3670,22 +3788,11 @@ var PtyToolServer = class {
   name;
   tools;
   http = null;
-  transport = null;
-  mcp = null;
+  sessions = /* @__PURE__ */ new Map();
   token = randomBytes(24).toString("base64url");
   async start() {
-    const mcp = new McpServer({ name: this.name, version: "1.0.0" });
-    const register = mcp.tool.bind(mcp);
-    for (const tool2 of this.tools) {
-      register(tool2.name, tool2.description, tool2.schema, (args) => tool2.handler(args));
-    }
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomBytes(16).toString("hex"),
-      enableJsonResponse: true
-    });
-    await mcp.connect(transport);
     const server = createServer2((req, res) => {
-      void this.handle(req, res, transport);
+      void this.handle(req, res);
     });
     await new Promise((resolve, reject) => {
       server.once("error", reject);
@@ -3694,33 +3801,84 @@ var PtyToolServer = class {
     const address = server.address();
     const port = address && typeof address === "object" ? address.port : 0;
     this.http = server;
-    this.transport = transport;
-    this.mcp = mcp;
     return { url: `http://${LOOPBACK}:${port}/mcp`, token: this.token };
   }
-  async handle(req, res, transport) {
+  /** Fresh McpServer with every tool registered — one per MCP session. */
+  buildMcpServer() {
+    const mcp = new McpServer({ name: this.name, version: "1.0.0" });
+    const register = mcp.tool.bind(mcp);
+    for (const tool2 of this.tools) {
+      register(tool2.name, tool2.description, tool2.schema, (args) => tool2.handler(args));
+    }
+    return mcp;
+  }
+  async handle(req, res) {
     if (req.headers.authorization !== `Bearer ${this.token}`) {
       res.writeHead(401).end();
       return;
     }
     try {
-      await transport.handleRequest(req, res);
+      const sessionId = req.headers["mcp-session-id"];
+      if (typeof sessionId === "string") {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          jsonRpcError(res, 404, -32001, "Session not found");
+          return;
+        }
+        await session.transport.handleRequest(req, res);
+        return;
+      }
+      if (req.method !== "POST") {
+        jsonRpcError(res, 400, -32600, "Bad Request: Mcp-Session-Id header is required");
+        return;
+      }
+      const body = await readJsonBody(req);
+      const messages = Array.isArray(body) ? body : [body];
+      if (!messages.some((m) => isInitializeRequest(m))) {
+        jsonRpcError(res, 400, -32600, "Bad Request: Mcp-Session-Id header is required");
+        return;
+      }
+      await this.openSession(req, res, body);
     } catch {
       if (res.headersSent) res.end();
       else res.writeHead(500).end();
     }
   }
-  async close() {
-    try {
-      await this.transport?.close();
-    } catch {
+  /** Connect a fresh transport + McpServer pair and serve the initialize. */
+  async openSession(req, res, parsedBody) {
+    const mcp = this.buildMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomBytes(16).toString("hex"),
+      enableJsonResponse: true,
+      onsessioninitialized: (sid) => {
+        this.sessions.set(sid, { transport, mcp });
+        this.evictOverflow(sid);
+      }
+    });
+    transport.onclose = () => {
+      const sid = transport.sessionId;
+      if (sid && this.sessions.get(sid)?.transport === transport) {
+        this.sessions.delete(sid);
+      }
+    };
+    await mcp.connect(transport);
+    await transport.handleRequest(req, res, parsedBody);
+  }
+  /** Drop oldest abandoned sessions past MAX_SESSIONS (never the newest). */
+  evictOverflow(currentSid) {
+    for (const [sid, session] of this.sessions) {
+      if (this.sessions.size <= MAX_SESSIONS) break;
+      if (sid === currentSid) continue;
+      this.sessions.delete(sid);
+      void closeSession(session);
     }
-    this.transport = null;
-    try {
-      await this.mcp?.close();
-    } catch {
+  }
+  async close() {
+    const sessions = [...this.sessions.values()];
+    this.sessions.clear();
+    for (const session of sessions) {
+      await closeSession(session);
     }
-    this.mcp = null;
     const http = this.http;
     this.http = null;
     if (http) {
@@ -3730,6 +3888,27 @@ var PtyToolServer = class {
     }
   }
 };
+async function closeSession(session) {
+  try {
+    await session.transport.close();
+  } catch {
+  }
+  try {
+    await session.mcp.close();
+  } catch {
+  }
+}
+function jsonRpcError(res, status, code, message) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id: null }));
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
 async function startToolServers(mcpServers, tempDir) {
   const servers = [];
   const config = {};
@@ -3747,8 +3926,23 @@ async function startToolServers(mcpServers, tempDir) {
   return { servers, mcpConfigPath };
 }
 
-// src/harness/pty/session.ts
+// src/harness/pty/pty-support.ts
+import { stat as stat3 } from "fs/promises";
 var MAX_DIAGNOSTIC_OUTPUT = 4e3;
+var MAX_BETWEEN_TURN_BUFFER = 500;
+var SUBMIT_SETTLE_MS = 300;
+var SUBMIT_NUDGE_INTERVAL_MS = 2e3;
+var SUBMIT_NUDGE_MAX_PRESSES = 5;
+var SUBMIT_NUDGE_SLOW_INTERVAL_MS = 5e3;
+var SUBMIT_NUDGE_WINDOW_MS = 9e4;
+function turnOptionsFrom(options) {
+  return {
+    canUseTool: options.canUseTool,
+    promptDelivery: options.promptDelivery,
+    planDialogAutoAccept: options.planDialogAutoAccept,
+    abortController: options.abortController
+  };
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
@@ -3771,16 +3965,13 @@ function inheritedEnv(socketPath) {
     if (typeof value === "string") env[key] = value;
   }
   env.CONVEYOR_HOOK_SOCKET = socketPath;
+  env.MCP_TIMEOUT ??= "60000";
+  env.MCP_TOOL_TIMEOUT ??= "180000";
   return env;
 }
 function buildPromptBytes(text) {
   return `\x1B[200~${text}\x1B[201~`;
 }
-var SUBMIT_SETTLE_MS = 300;
-var SUBMIT_NUDGE_INTERVAL_MS = 2e3;
-var SUBMIT_NUDGE_MAX_PRESSES = 5;
-var SUBMIT_NUDGE_SLOW_INTERVAL_MS = 5e3;
-var SUBMIT_NUDGE_WINDOW_MS = 9e4;
 function sleep3(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -3812,18 +4003,41 @@ function parseUserQuestions(input) {
   }
   return questions;
 }
+
+// src/harness/pty/session.ts
 var PtySession = class {
   constructor(prompt, options, resume, bridge) {
-    this.prompt = prompt;
     this.options = options;
     this.resume = resume;
     this.bridge = bridge;
+    this.turnPrompt = prompt;
+    this.turn = turnOptionsFrom(options);
   }
-  prompt;
   options;
   resume;
   bridge;
-  queue = new AsyncEventQueue();
+  // The current turn's event stream. Null between turns (process parked) — the
+  // process outlives any single turn, so the queue is per-turn, not per-process.
+  activeQueue = null;
+  // The drain generator for the current turn, captured at turn-start and bound
+  // to that turn's queue instance. events() returns THIS, not a fresh drain of
+  // activeQueue — a turn can end (closing + nulling activeQueue) synchronously
+  // within beginPassiveTurn (a buffered result) before the consumer calls
+  // events(), and the consumer must still drain the already-buffered records.
+  turnStream = null;
+  // Transcript events that arrive with no turn draining (parked window). A
+  // passive turn replays these; beginTurn drops them.
+  betweenTurnBuffer = [];
+  // Leading-edge guard so a burst of parked activity fires onPassiveActivity
+  // once, not per event. Reset when a turn (re)starts.
+  passiveSignaled = false;
+  passiveListener = null;
+  // Set once the CLI process actually exits (distinct from _toreDown, which is
+  // our own teardown). Blocks reuse of a dead process.
+  exited = false;
+  // Whether the turn that just ended did so via a clean transcript `result`
+  // (eligible for parking) vs. an abort/error (must teardown).
+  lastTurnCleanResult = false;
   socket = null;
   tailer = null;
   pty = null;
@@ -3852,27 +4066,173 @@ var PtySession = class {
   // Submit-nudge state (see armSubmitNudge).
   pendingSubmitNudge = false;
   submitNudgeTimer = null;
+  // Per-turn state: the prompt to feed and the per-turn options subset. Both
+  // start from the constructor args (turn 1) and are replaced by beginTurn.
+  turnPrompt;
+  turn;
   onIdle(listener) {
     this.idleListeners.push(listener);
   }
   onExit(listener) {
     this.exitListeners.push(listener);
   }
+  /** Subscribe to parked-window transcript activity (human typed into the idle
+   *  TUI). Returns unsubscribe. Only one listener is retained. */
+  onPassiveActivity(listener) {
+    this.passiveListener = listener;
+    return () => {
+      if (this.passiveListener === listener) this.passiveListener = null;
+    };
+  }
   get isToreDown() {
     return this._toreDown;
   }
+  /** True once the underlying CLI process has exited. */
+  get hasExited() {
+    return this.exited;
+  }
+  /** True when the last turn ended via a clean transcript result (parkable). */
+  get endedCleanly() {
+    return this.lastTurnCleanResult;
+  }
+  /** The deterministic session UUID this process is bound to. */
+  get sessionUuid() {
+    return this.resume ?? this.options.sessionId;
+  }
+  /** Fingerprint of the spawn-time options a reused process cannot change. */
+  get spawnFingerprint() {
+    return spawnOptionsFingerprint({
+      model: this.options.model,
+      permissionMode: this.options.permissionMode,
+      ...this.options.appendSystemPrompt ? { appendSystemPrompt: this.options.appendSystemPrompt } : {},
+      cwd: this.options.cwd
+    });
+  }
+  /**
+   * Whether this parked process can serve a turn wanting `resume`/`fingerprint`.
+   * Requires: live (not torn down / not exited), idle (no turn draining), a
+   * matching resume target, and matching spawn options.
+   */
+  canReuse(resume, fingerprint) {
+    return !this._toreDown && !this.exited && this.activeQueue === null && resume !== void 0 && resume === this.sessionUuid && fingerprint === this.spawnFingerprint;
+  }
   get hookSocketPath() {
     return this.socket ? this.socket.socketPath : null;
   }
   events() {
-    return this.queue.drain();
+    if (!this.turnStream) {
+      const empty = new AsyncEventQueue();
+      empty.close();
+      return empty.drain();
+    }
+    return this.turnStream;
+  }
+  /**
+   * Route a harness event to the current turn's queue, or — when no turn is
+   * draining (the process is parked) — into the between-turn buffer, firing the
+   * passive-activity signal once per parked window.
+   */
+  pushEvent(event) {
+    if (this.activeQueue) {
+      this.activeQueue.push(event);
+      return;
+    }
+    this.betweenTurnBuffer.push(event);
+    if (this.betweenTurnBuffer.length > MAX_BETWEEN_TURN_BUFFER) {
+      this.betweenTurnBuffer.shift();
+    }
+    if (!this.passiveSignaled) {
+      this.passiveSignaled = true;
+      this.passiveListener?.();
+    }
+  }
+  /**
+   * Begin a follow-up turn on the ALREADY-RUNNING process: fresh per-turn state
+   * and queue, rewire the abort listener to this turn's controller, then feed
+   * the prompt into the live pty. The caller must have verified canReuse().
+   */
+  async beginTurn(prompt, options) {
+    this.turnPrompt = prompt;
+    this.turn = turnOptionsFrom(options);
+    this.resetForTurn();
+    this.betweenTurnBuffer = [];
+    this.activeQueue = new AsyncEventQueue();
+    this.turnStream = this.activeQueue.drain();
+    if (!this.rearmAbort()) return;
+    await this.feedPrompt();
+  }
+  /**
+   * Begin a PASSIVE turn: a human typed into the parked TUI and the CLI is
+   * producing transcript records with no prompt from us. Replay the buffered
+   * records into a fresh queue (a buffered `result` ends the turn at once) and
+   * let live records continue to flow.
+   */
+  beginPassiveTurn(turn) {
+    this.turn = turn;
+    this.resetForTurn();
+    const buffered = this.betweenTurnBuffer;
+    this.betweenTurnBuffer = [];
+    this.activeQueue = new AsyncEventQueue();
+    this.turnStream = this.activeQueue.drain();
+    if (!this.rearmAbort()) return;
+    for (const event of buffered) {
+      this.activeQueue?.push(event);
+      if (event.type === "result") this.endTurn(true);
+    }
+  }
+  /** Reset per-turn state shared by beginTurn/beginPassiveTurn. */
+  resetForTurn() {
+    this.sawResult = false;
+    this.lastTurnCleanResult = false;
+    this.passiveSignaled = false;
+    this.disarmSubmitNudge();
+    this.disarmPlanDialogAutoAccept();
+  }
+  /**
+   * (Re)register the abort→teardown listener on the current turn's controller,
+   * removing any prior one. Returns false (after tearing down) when the signal
+   * is already aborted, so callers can bail.
+   */
+  rearmAbort() {
+    if (this.abortHandler && this.turn.abortController) {
+      this.turn.abortController.signal.removeEventListener("abort", this.abortHandler);
+    }
+    this.abortHandler = null;
+    const signal = this.turn.abortController?.signal;
+    if (!signal) return true;
+    if (signal.aborted) {
+      void this.teardown();
+      return false;
+    }
+    this.abortHandler = () => {
+      void this.teardown();
+    };
+    signal.addEventListener("abort", this.abortHandler, { once: true });
+    return true;
+  }
+  /**
+   * End the current turn WITHOUT killing the process: close+null the queue so
+   * the consumer's generator completes, and unhook the (now-finished) turn's
+   * abort listener so a later abort of that controller can't teardown a process
+   * we intend to reuse. The process stays alive (parked) for the next turn.
+   */
+  endTurn(clean) {
+    this.lastTurnCleanResult = clean;
+    this.activeQueue?.close();
+    this.activeQueue = null;
+    if (this.abortHandler && this.turn.abortController) {
+      this.turn.abortController.signal.removeEventListener("abort", this.abortHandler);
+      this.abortHandler = null;
+    }
   }
   async start() {
     const sessionId = this.resume ?? this.options.sessionId;
     if (!sessionId) {
       throw new Error("PtySession requires options.sessionId or a resume target");
     }
-    const signal = this.options.abortController?.signal;
+    this.activeQueue = new AsyncEventQueue();
+    this.turnStream = this.activeQueue.drain();
+    const signal = this.turn.abortController?.signal;
     if (signal?.aborted) {
       await this.teardown();
       return;
@@ -3952,7 +4312,7 @@ var PtySession = class {
     this.unsubResize?.();
     this.unsubResize = null;
     if (this.abortHandler) {
-      this.options.abortController?.signal.removeEventListener("abort", this.abortHandler);
+      this.turn.abortController?.signal.removeEventListener("abort", this.abortHandler);
       this.abortHandler = null;
     }
     try {
@@ -3976,7 +4336,8 @@ var PtySession = class {
     }
     this.toolServers = [];
     this.mcpConfigPath = null;
-    this.queue.close();
+    this.activeQueue?.close();
+    this.activeQueue = null;
     if (this.tempDir) {
       await rm4(this.tempDir, { recursive: true, force: true });
       this.tempDir = "";
@@ -4037,18 +4398,18 @@ var PtySession = class {
   }
   async deliverPrompt(text) {
     this.writeStdin(buildPromptBytes(text));
-    if (this.options.promptDelivery === "prefill") return;
+    if (this.turn.promptDelivery === "prefill") return;
     await sleep3(SUBMIT_SETTLE_MS);
     if (this._toreDown) return;
     this.writeStdin("\r");
     this.armSubmitNudge();
   }
   async feedPrompt() {
-    if (typeof this.prompt === "string") {
-      await this.deliverPrompt(this.prompt);
+    if (typeof this.turnPrompt === "string") {
+      await this.deliverPrompt(this.turnPrompt);
       return;
     }
-    for await (const message of this.prompt) {
+    for await (const message of this.turnPrompt) {
       const content = message.message.content;
       const text = typeof content === "string" ? content : JSON.stringify(content);
       await this.deliverPrompt(text);
@@ -4096,7 +4457,7 @@ var PtySession = class {
     }
   }
   handleProgress(progress) {
-    this.queue.push({
+    this.pushEvent({
       type: "tool_progress",
       ...progress.tool_name === void 0 ? {} : { tool_name: progress.tool_name },
       ...progress.elapsed_time_seconds === void 0 ? {} : { elapsed_time_seconds: progress.elapsed_time_seconds }
@@ -4112,10 +4473,13 @@ var PtySession = class {
   async handlePreToolUse(request) {
     if (request.tool_name === "AskUserQuestion") {
       this.disarmSubmitNudge();
-      this.queue.push({ type: "user_question", questions: parseUserQuestions(request.tool_input) });
+      this.pushEvent({
+        type: "user_question",
+        questions: parseUserQuestions(request.tool_input)
+      });
       return { decision: "allow" };
     }
-    const canUseTool = this.options.canUseTool;
+    const canUseTool = this.turn.canUseTool;
     let verdict;
     if (canUseTool) {
       const result = await canUseTool(request.tool_name, request.tool_input);
@@ -4123,7 +4487,7 @@ var PtySession = class {
     } else {
       verdict = { decision: "allow" };
     }
-    if (verdict.decision === "allow" && request.tool_name === "ExitPlanMode" && this.options.planDialogAutoAccept) {
+    if (verdict.decision === "allow" && request.tool_name === "ExitPlanMode" && this.turn.planDialogAutoAccept) {
       this.armPlanDialogAutoAccept();
     }
     return verdict;
@@ -4159,29 +4523,31 @@ var PtySession = class {
   handleTranscriptEvent(event) {
     if (this.pendingPlanApproval) this.disarmPlanDialogAutoAccept();
     if (this.pendingSubmitNudge) this.disarmSubmitNudge();
-    this.queue.push(event);
+    this.pushEvent(event);
     if (event.type === "result") {
       this.sawResult = true;
       for (const listener of this.idleListeners) listener();
-      this.queue.close();
+      this.endTurn(true);
     }
   }
   async finalizeOnExit(exitCode) {
     this.coalescer?.flush();
+    this.exited = true;
     if (this._toreDown) return;
     if (this.tailer) {
       this.tailer.close();
       await this.tailer.flush();
     }
-    if (!this.sawResult) {
-      this.queue.push({
+    if (!this.sawResult && this.activeQueue) {
+      this.activeQueue.push({
         type: "result",
         subtype: "error",
         errors: buildExitErrors(exitCode, this.recentOutput, resolveClaudeBinary())
       });
     }
     for (const listener of this.exitListeners) listener(exitCode);
-    this.queue.close();
+    this.activeQueue?.close();
+    this.activeQueue = null;
   }
 };
 
@@ -4351,6 +4717,15 @@ async function removeConveyorCredentials(env = process.env) {
 }
 
 // src/harness/pty/index.ts
+var ENDED_GRACE_MS = 4e3;
+function fingerprintOf(options) {
+  return spawnOptionsFingerprint({
+    model: options.model,
+    permissionMode: options.permissionMode,
+    ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
+    cwd: options.cwd
+  });
+}
 var PtyHarness = class {
   /**
    * `bridge` relays raw terminal I/O to/from the S2 server (and on to the S5
@@ -4363,34 +4738,143 @@ var PtyHarness = class {
   bridge;
   /** The session currently streaming events, if any — repaint target. */
   activeSession = null;
+  /** A completed-but-alive session kept for the next turn (keep-alive). */
+  parked = null;
+  /** Pending "process died" → `pty:ended` timer (grace window). */
+  endedTimer = null;
+  /** Passive-activity subscriber, re-attached to whichever session is parked. */
+  passiveHandler = null;
   /**
-   * Wiggle the live pty's size so the CLI repaints its whole screen. No-op
-   * between queries or on the SDK harness. Called after a socket reconnect so
-   * the server's (per-process, possibly brand-new) scrollback ring re-seeds
-   * and the Connected-TUI terminal reappears.
+   * Wiggle the live pty's size so the CLI repaints its whole screen. No-op on
+   * the SDK harness. Falls back to the parked session so an API reconnect while
+   * the CLI is idle still re-seeds the server's scrollback ring.
    */
   forceRepaint() {
-    this.activeSession?.forceRepaint();
+    (this.activeSession ?? this.parked)?.forceRepaint();
   }
   async *executeQuery(opts) {
-    const session = new PtySession(
-      opts.prompt,
-      opts.options,
-      opts.resume ?? opts.options.resume,
-      this.bridge
-    );
-    await ensureClaudeCredentials();
-    await ensureClaudeOnboarding(process.env, opts.options.cwd);
-    await session.start();
+    const want = opts.resume ?? opts.options.resume;
+    const fingerprint = fingerprintOf(opts.options);
+    let session;
+    if (this.parked?.canReuse(want, fingerprint)) {
+      session = this.parked;
+      this.parked = null;
+      this.cancelEndedTimer();
+      await session.beginTurn(opts.prompt, opts.options);
+    } else {
+      if (this.parked) {
+        const stale = this.parked;
+        this.parked = null;
+        this.cancelEndedTimer();
+        await stale.teardown();
+      }
+      session = new PtySession(opts.prompt, opts.options, want, this.bridge);
+      await ensureClaudeCredentials();
+      await ensureClaudeOnboarding(process.env, opts.options.cwd);
+      session.onExit(() => this.handleSessionExit(session));
+      await session.start();
+    }
+    yield* this.drain(session);
+  }
+  /**
+   * PTY-only: subscribe to "the parked CLI produced transcript activity with no
+   * query running" (a human typed into the idle Connected-TUI). Attaches to the
+   * currently-parked session and to any session parked later.
+   */
+  onPassiveActivity(handler) {
+    this.passiveHandler = handler;
+    const unsubParked = this.parked?.onPassiveActivity(handler);
+    return () => {
+      if (this.passiveHandler === handler) this.passiveHandler = null;
+      unsubParked?.();
+    };
+  }
+  /**
+   * PTY-only: drain a passive turn against the parked process — the human
+   * already submitted in the TUI, so no prompt is fed. Empty stream when nothing
+   * is parked.
+   */
+  async *executePassiveTurn(options) {
+    const session = this.parked;
+    if (!session) return;
+    this.parked = null;
+    this.cancelEndedTimer();
+    session.beginPassiveTurn(options);
+    yield* this.drain(session);
+  }
+  /**
+   * Shared query/passive-turn drain: stream the session's events, then either
+   * park it (clean result → keep the process for the next turn) or tear it down
+   * (abort/error/early-return → real death, schedule the ended signal).
+   */
+  async *drain(session) {
     this.activeSession = session;
+    let clean = false;
     try {
       for await (const event of session.events()) {
         yield event;
       }
+      clean = session.endedCleanly && !session.isToreDown && !session.hasExited;
     } finally {
       if (this.activeSession === session) this.activeSession = null;
-      await session.teardown();
+      if (clean) {
+        this.park(session);
+      } else {
+        await session.teardown();
+        this.scheduleEnded();
+      }
+    }
+  }
+  /** Park a live, idle session for reuse and (re)wire the passive listener. */
+  park(session) {
+    this.parked = session;
+    if (this.passiveHandler) session.onPassiveActivity(this.passiveHandler);
+  }
+  /**
+   * Parked/active process exited on its own (crash). A mid-turn death is
+   * handled by drain()'s finally; here we only act on a death while PARKED —
+   * tear down the husk and report ended immediately (no respawn is coming).
+   */
+  handleSessionExit(session) {
+    if (this.parked !== session) return;
+    this.parked = null;
+    void session.teardown();
+    this.notifyEnded();
+  }
+  scheduleEnded() {
+    if (this.endedTimer) return;
+    this.endedTimer = setTimeout(() => {
+      this.endedTimer = null;
+      this.notifyEnded();
+    }, ENDED_GRACE_MS);
+  }
+  cancelEndedTimer() {
+    if (this.endedTimer) {
+      clearTimeout(this.endedTimer);
+      this.endedTimer = null;
+    }
+  }
+  notifyEnded() {
+    this.cancelEndedTimer();
+    this.bridge?.sendEnded?.();
+  }
+  /**
+   * Tear down every live process (parked + active) and signal ended. Called by
+   * the runner on stop/shutdown so the parked CLI never outlives the session and
+   * the Connected-TUI tab hides promptly.
+   */
+  async dispose() {
+    this.cancelEndedTimer();
+    const toKill = [this.parked, this.activeSession].filter((s) => s !== null);
+    this.parked = null;
+    this.activeSession = null;
+    for (const session of toKill) {
+      try {
+        await session.teardown();
+      } catch {
+      }
     }
+    if (toKill.length > 0) this.notifyEnded();
   }
   createMcpServer(config) {
     return new PtyMcpServer(config.name, config.tools);
@@ -8042,6 +8526,18 @@ async function runPrefilledFollowUp(host, context, options, resume, followUpCont
   });
   await trackAndRun(host, context, queryOptions, agentQuery);
 }
+async function runPassiveTurn(host, context) {
+  if (host.isStopped()) return;
+  if (!host.harness.executePassiveTurn) return;
+  const options = buildQueryOptions(host, context);
+  const passiveQuery = host.harness.executePassiveTurn(options);
+  host.activeQuery = passiveQuery;
+  try {
+    await processEvents(passiveQuery, context, host);
+  } finally {
+    host.activeQuery = null;
+  }
+}
 async function trackAndRun(host, context, options, agentQuery) {
   if (host.harnessKind === "pty" && options.promptDelivery !== "prefill") {
     agentQuery = watchForParkedTui(agentQuery, host);
@@ -8377,6 +8873,7 @@ function resolveHarnessKind() {
 function buildPtyBridge(connection) {
   return {
     sendOutput: (data, dims) => connection.sendPtyOutput(data, dims),
+    sendEnded: () => connection.sendPtyEnded(),
     onInput: (handler) => connection.onPtyInput(handler),
     onResize: (handler) => connection.onPtyResize(handler)
   };
@@ -8448,6 +8945,24 @@ var QueryBridge = class {
   resume() {
     this._stopped = false;
   }
+  /**
+   * Tear down any parked/active CLI process the harness is keeping alive between
+   * turns (PTY keep-alive). Called by SessionRunner on stop/shutdown so the
+   * process never outlives the session and the Connected-TUI tab hides. No-op on
+   * the SDK harness.
+   */
+  async dispose() {
+    await this.harness.dispose?.();
+  }
+  /**
+   * Subscribe to "a human typed into the parked, idle TUI" (PTY keep-alive).
+   * SessionRunner uses this to wake a passive turn. Returns unsubscribe; no-op
+   * (returns a noop unsubscribe) on the SDK harness.
+   */
+  onPassiveActivity(handler) {
+    return this.harness.onPassiveActivity?.(handler) ?? (() => {
+    });
+  }
   /**
    * How the INITIAL instructions for this task would be delivered — "prefill"
    * means the TUI input is pre-filled but unsubmitted, awaiting the human.
@@ -8496,6 +9011,34 @@ var QueryBridge = class {
       this._abortController = null;
     }
   }
+  /**
+   * Drive a passive turn: the parked CLI is producing transcript records because
+   * a human typed into the idle Connected-TUI. Mirrors execute()'s setup (fresh
+   * abort controller so a superseding chat message can abort, host construction,
+   * error classification) but runs the promptless passive drain instead of a
+   * full query.
+   */
+  async executePassive(context) {
+    this._stopped = false;
+    this._wasRateLimited = false;
+    this._abortController = new AbortController();
+    const host = this.buildHost();
+    try {
+      await runPassiveTurn(host, context);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isAbort = this._stopped || /abort/i.test(msg);
+      if (isAbort) {
+        logger3.info("Passive turn stopped", { error: msg });
+      } else {
+        logger3.error("Passive turn failed", { error: msg });
+        this.connection.sendEvent({ type: "error", message: msg });
+      }
+    } finally {
+      this.mode.pendingModeRestart = false;
+      this._abortController = null;
+    }
+  }
   // ── QueryHost construction ──────────────────────────────────────────
   buildHost() {
     const bridge = this;
@@ -8615,6 +9158,80 @@ function readAgentVersion() {
   return null;
 }
 
+// src/execution/usage-sampler.ts
+var logger4 = createServiceLogger("usage-sampler");
+var OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var OAUTH_USAGE_BETA = "oauth-2025-04-20";
+var KNOWN_RATE_LIMIT_TYPES = [
+  "five_hour",
+  "seven_day",
+  "seven_day_opus",
+  "seven_day_sonnet"
+];
+function normalizeUtilization(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+  const fraction = raw > 1 ? raw / 100 : raw;
+  return Math.max(0, Math.min(1, fraction));
+}
+function extractBucket(value) {
+  if (typeof value === "number") {
+    const utilization = normalizeUtilization(value);
+    return utilization === null ? null : { utilization, status: "allowed" };
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    const utilization = normalizeUtilization(
+      obj.utilization ?? obj.used ?? obj.percent ?? obj.percentage
+    );
+    if (utilization === null) return null;
+    const status = typeof obj.status === "string" ? obj.status : "allowed";
+    return { utilization, status };
+  }
+  return null;
+}
+function mapUsageResponse(data) {
+  if (!data || typeof data !== "object") return [];
+  const root = data;
+  const candidates = [root];
+  for (const key of ["usage", "rate_limits", "rateLimits"]) {
+    const nested = root[key];
+    if (nested && typeof nested === "object") {
+      candidates.push(nested);
+    }
+  }
+  for (const container of candidates) {
+    const samples = [];
+    for (const type of KNOWN_RATE_LIMIT_TYPES) {
+      const bucket = extractBucket(container[type]);
+      if (bucket) samples.push({ rateLimitType: type, ...bucket });
+    }
+    if (samples.length > 0) return samples;
+  }
+  return [];
+}
+async function sampleKeyUsage(token) {
+  if (!token) return [];
+  try {
+    const res = await fetch(OAUTH_USAGE_URL, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": OAUTH_USAGE_BETA
+      }
+    });
+    if (!res.ok) {
+      logger4.info("OAuth usage endpoint returned non-200", { status: res.status });
+      return [];
+    }
+    const data = await res.json();
+    return mapUsageResponse(data);
+  } catch (error) {
+    logger4.info("OAuth usage sample failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return [];
+  }
+}
+
 // src/runner/port-discovery.ts
 import { readFile as readFile4 } from "fs/promises";
 import { execFile } from "child_process";
@@ -8913,7 +9530,8 @@ var SessionRunner = class _SessionRunner {
         }
       },
       onTokenRefresh: () => void this.refreshGithubToken(),
-      onGitFlush: () => void this.periodicGitFlush()
+      onGitFlush: () => void this.periodicGitFlush(),
+      onUsageSample: () => void this.sampleAndReportKeyUsage()
     });
   }
   get state() {
@@ -8939,6 +9557,7 @@ var SessionRunner = class _SessionRunner {
     this.wireConnectionCallbacks();
     this.lifecycle.startHeartbeat();
     this.lifecycle.startTokenRefresh();
+    this.lifecycle.startUsageSample();
     const { pendingMessages: serverMessages } = await this.connection.call("connectAgent", {
       sessionId: this.sessionId
     });
@@ -9095,16 +9714,21 @@ var SessionRunner = class _SessionRunner {
           break;
         }
         this.interrupted = false;
-        await this.callbacks.onEvent({
-          type: "user_message",
-          content: msg.content,
-          userId: msg.userId
-        });
-        if (this.prefillEligible(msg)) {
-          await this.runPrefilledMessage(msg, this.mode.effectiveMode);
-        } else {
+        if (msg.source === "pty_passive") {
           await this.setState("running");
-          await this.executeQuery(msg.content);
+          await this.executePassive();
+        } else {
+          await this.callbacks.onEvent({
+            type: "user_message",
+            content: msg.content,
+            userId: msg.userId
+          });
+          if (this.prefillEligible(msg)) {
+            await this.runPrefilledMessage(msg, this.mode.effectiveMode);
+          } else {
+            await this.setState("running");
+            await this.executeQuery(msg.content);
+          }
         }
         if (this.queryBridge?.isDiscoveryCompleted) {
           process.stderr.write(
@@ -9331,6 +9955,28 @@ var SessionRunner = class _SessionRunner {
       throw err;
     }
   }
+  /**
+   * A human typed into the parked, idle Connected-TUI (keep-alive PTY). Wake the
+   * core loop with a sentinel so it drains a passive turn. No-op once stopped.
+   */
+  onPassiveTuiActivity() {
+    if (this.stopped) return;
+    this.injectMessage({ content: "", userId: "human", source: "pty_passive" });
+  }
+  /** Run queryBridge.executePassive, swallowing abort errors from stop/softStop. */
+  async executePassive() {
+    if (!this.fullContext || !this.queryBridge) return;
+    this.agentSpokeThisTurn = false;
+    try {
+      await this.queryBridge.executePassive(this.fullContext);
+    } catch (err) {
+      if (this.interrupted || this.stopped) {
+        process.stderr.write("[conveyor-agent] Passive turn aborted by stop/softStop signal\n");
+        return;
+      }
+      throw err;
+    }
+  }
   // ── Stop / soft-stop ───────────────────────────────────────────────
   /** Periodic best-effort WIP commit + push during normal agent execution.
    *  Covers ungraceful pod termination (OOMKilled, node crash/eviction) where
@@ -9365,6 +10011,24 @@ var SessionRunner = class _SessionRunner {
       this.periodicFlushInFlight = false;
     }
   }
+  /** Sample the running Claude subscription key's rate-limit utilization from the
+   *  Anthropic OAuth usage endpoint and report it as `rate_limit_update` events.
+   *  The API (`persistRateLimitSnapshot`) attributes them to the key this session
+   *  launched under, keeping User Settings + the PtY-tab usage widget fresh and
+   *  `selectBestKey` rotation honest. Best-effort — never throws, no-op when the
+   *  pod has no OAuth token (e.g. API-key projects). */
+  async sampleAndReportKeyUsage() {
+    if (this.stopped) return;
+    const samples = await sampleKeyUsage(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    for (const sample of samples) {
+      this.connection.sendEvent({
+        type: "rate_limit_update",
+        rateLimitType: sample.rateLimitType,
+        utilization: sample.utilization,
+        status: sample.status
+      });
+    }
+  }
   /** PUT the WorkPreservation snapshot tar to the bundle's capability URL
    *  when this pod is v3 (CONVEYOR_SNAPSHOT_UPLOAD_URL set). Never throws. */
   async uploadGcsSnapshotIfConfigured() {
@@ -9415,6 +10079,8 @@ var SessionRunner = class _SessionRunner {
   stop() {
     this.stopped = true;
     this.queryBridge?.stop();
+    void this.queryBridge?.dispose().catch(() => {
+    });
     this.portDiscovery?.stop();
     this.lifecycle.destroy();
     this.connection.disconnect();
@@ -9602,6 +10268,7 @@ var SessionRunner = class _SessionRunner {
       this.connection.emitModeChanged(newMode);
       this.softStop();
     };
+    bridge.onPassiveActivity(() => this.onPassiveTuiActivity());
     return bridge;
   }
   // ── Private helpers ────────────────────────────────────────────────
@@ -9718,6 +10385,10 @@ var SessionRunner = class _SessionRunner {
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
     this.portDiscovery?.stop();
     this.lifecycle.destroy();
+    try {
+      await this.queryBridge?.dispose();
+    } catch {
+    }
     try {
       await this.setState(finalState);
     } catch {
@@ -9897,6 +10568,7 @@ export {
   flushPendingChanges,
   pushToOrigin,
   PlanSync,
+  sampleKeyUsage,
   awaitGitReady,
   uploadSnapshotToGcs,
   captureSnapshot,
@@ -9913,4 +10585,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-S72TAMGA.js.map
+//# sourceMappingURL=chunk-DAHP6JPD.js.map