chatroom-cli 1.55.0 → 1.55.1

package/dist/index.js

@@ -26374,12 +26374,7 @@ var init_pi_agent_service = __esm(() => {
       });
     }
     spawnPiRpcProcess(args2) {
-      const rpcArgs = [
-        "--mode",
-        "rpc",
-        "--session-dir",
-        getPiSessionDir(args2.workingDir)
-      ];
+      const rpcArgs = ["--mode", "rpc", "--session-dir", getPiSessionDir(args2.workingDir)];
       if (args2.sessionId) {
         rpcArgs.push("--session", args2.sessionId);
       }
@@ -26441,6 +26436,9 @@ var init_pi_agent_service = __esm(() => {
     wireRpcProcess(args2) {
       const { childProcess, context: context4, workingDir, model, harnessSessionId } = args2;
       const pid = childProcess.pid;
+      if (pid == null) {
+        throw new Error("Pi RPC process has no PID");
+      }
       this.childProcesses.set(pid, childProcess);
       this.trackedSessions.set(pid, { harnessSessionId, workingDir, model });
       const entry = this.registerProcess(pid, context4);
@@ -26448,7 +26446,12 @@ var init_pi_agent_service = __esm(() => {
       const chatroomSuffix = context4.chatroomId ? `@${context4.chatroomId.slice(-6)}` : "";
       const logPrefix = `[pi:${roleTag}${chatroomSuffix}`;
       const outputCallbacks = [];
+      const logLineCallbacks = [];
       const agentEndCallbacks = [];
+      const emitLogLine = (line) => {
+        for (const cb of logLineCallbacks)
+          cb(line);
+      };
       const onExit4 = (cb) => {
         childProcess.on("exit", (code2, signal) => {
           this.childProcesses.delete(pid);
@@ -26463,6 +26466,9 @@ var init_pi_agent_service = __esm(() => {
       const onAgentEnd = (cb) => {
         agentEndCallbacks.push(cb);
       };
+      const onLogLine = (cb) => {
+        logLineCallbacks.push(cb);
+      };
       const baseResult = {
         pid,
         harnessSessionId,
@@ -26471,43 +26477,54 @@ var init_pi_agent_service = __esm(() => {
           ...model ? { model } : {}
         },
         onExit: onExit4,
-        onOutput
+        onOutput,
+        onLogLine
+      };
+      const writeFormattedLogLine = (formatted) => {
+        process.stdout.write(`${formatted}
+`);
+        emitLogLine(formatted);
+      };
+      const onStderrData = (chunk2) => {
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+        emitLogLine(chunk2.toString());
+      };
+      const attachStderr = (stream) => {
+        if (!stream)
+          return;
+        stream.pipe(process.stderr, { end: false });
+        stream.on("data", onStderrData);
       };
       if (!childProcess.stdout) {
-        if (childProcess.stderr) {
-          childProcess.stderr.pipe(process.stderr, { end: false });
-          childProcess.stderr.on("data", () => {
-            entry.lastOutputAt = Date.now();
-            for (const cb of outputCallbacks)
-              cb();
-          });
-        }
+        attachStderr(childProcess.stderr);
         return baseResult;
       }
       const reader = args2.reader ?? new PiRpcReader(childProcess.stdout);
       let textBuffer = "";
       let thinkingBuffer = "";
-      const flushText = () => {
-        if (!textBuffer)
+      const flushBufferedLines = (buffer, kind, clear) => {
+        if (!buffer)
           return;
-        for (const line of textBuffer.split(`
+        for (const line of buffer.split(`
 `)) {
-          if (line)
-            process.stdout.write(`${logPrefix} text] ${line}
-`);
+          if (line) {
+            writeFormattedLogLine(`${logPrefix} ${kind}] ${line}`);
+          }
         }
-        textBuffer = "";
+        clear();
       };
-      const flushThinking = () => {
-        if (!thinkingBuffer)
-          return;
-        for (const line of thinkingBuffer.split(`
-`)) {
-          if (line)
-            process.stdout.write(`${logPrefix} thinking] ${line}
-`);
-        }
+      const flushText = () => flushBufferedLines(textBuffer, "text", () => {
+        textBuffer = "";
+      });
+      const flushThinking = () => flushBufferedLines(thinkingBuffer, "thinking", () => {
         thinkingBuffer = "";
+      });
+      const notifyOutput = () => {
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
       };
       reader.onTextDelta((delta) => {
         flushThinking();
@@ -26515,9 +26532,7 @@ var init_pi_agent_service = __esm(() => {
         if (textBuffer.includes(`
 `))
           flushText();
-        entry.lastOutputAt = Date.now();
-        for (const cb of outputCallbacks)
-          cb();
+        notifyOutput();
       });
       reader.onThinkingDelta((delta) => {
         flushText();
@@ -26525,14 +26540,10 @@ var init_pi_agent_service = __esm(() => {
         if (thinkingBuffer.includes(`
 `))
           flushThinking();
-        entry.lastOutputAt = Date.now();
-        for (const cb of outputCallbacks)
-          cb();
+        notifyOutput();
       });
       reader.onAnyEvent(() => {
-        entry.lastOutputAt = Date.now();
-        for (const cb of outputCallbacks)
-          cb();
+        notifyOutput();
       });
       reader.onAgentEnd(() => {
         flushText();
@@ -26546,22 +26557,13 @@ var init_pi_agent_service = __esm(() => {
         flushText();
         flushThinking();
         const argsStr = toolArgs != null ? ` args: ${JSON.stringify(toolArgs)}` : "";
-        process.stdout.write(`${logPrefix} tool: ${name}${argsStr}]
-`);
+        writeFormattedLogLine(`${logPrefix} tool: ${name}${argsStr}]`);
       });
       reader.onToolResult((name, result) => {
         const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-        process.stdout.write(`${logPrefix} tool_result: ${name} result: ${resultStr}]
-`);
+        writeFormattedLogLine(`${logPrefix} tool_result: ${name} result: ${resultStr}]`);
       });
-      if (childProcess.stderr) {
-        childProcess.stderr.pipe(process.stderr, { end: false });
-        childProcess.stderr.on("data", () => {
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
-      }
+      attachStderr(childProcess.stderr);
       return {
         ...baseResult,
         onAgentEnd
@@ -27629,12 +27631,14 @@ function closeCursorAgentOnFailure(agent, session, exitCode, force = false) {
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-stream-adapter.ts
 class CursorSdkStreamAdapter {
   logPrefix;
+  emitLogLine;
   agentEndCallbacks = [];
   outputCallbacks = [];
   agentEndEmitted = false;
   textBuffer = "";
-  constructor(logPrefix) {
+  constructor(logPrefix, emitLogLine) {
     this.logPrefix = logPrefix;
+    this.emitLogLine = emitLogLine;
   }
   onAgentEnd(cb) {
     this.agentEndCallbacks.push(cb);
@@ -27650,21 +27654,17 @@ class CursorSdkStreamAdapter {
         break;
       case "tool_call":
         this.flushText();
-        process.stdout.write(`${this.logPrefix} tool: ${message.call_id} ${message.name} ${JSON.stringify({ status: message.status, args: message.args })}]
-`);
+        this.writeLine(`${this.logPrefix} tool: ${message.call_id} ${message.name} ${JSON.stringify({ status: message.status, args: message.args })}]`);
         break;
       case "status":
-        process.stdout.write(`${this.logPrefix} status: ${message.status}]
-`);
+        this.writeLine(`${this.logPrefix} status: ${message.status}]`);
         break;
       case "thinking":
-        process.stdout.write(`${this.logPrefix} thinking] ${message.text}
-`);
+        this.writeLine(`${this.logPrefix} thinking] ${message.text}`);
         break;
       case "system":
         if (message.subtype === "init") {
-          process.stdout.write(`${this.logPrefix} system: init]
-`);
+          this.writeLine(`${this.logPrefix} system: init]`);
         }
         break;
       default:
@@ -27695,8 +27695,7 @@ class CursorSdkStreamAdapter {
     for (const line of this.textBuffer.split(`
 `)) {
       if (line)
-        process.stdout.write(`${this.logPrefix} text] ${line}
-`);
+        this.writeLine(`${this.logPrefix} text] ${line}`);
     }
     this.textBuffer = "";
   }
@@ -27705,11 +27704,15 @@ class CursorSdkStreamAdapter {
       return;
     this.agentEndEmitted = true;
     this.flushText();
-    process.stdout.write(`${this.logPrefix} agent_end]
-`);
+    this.writeLine(`${this.logPrefix} agent_end]`);
     for (const cb of this.agentEndCallbacks)
       cb();
   }
+  writeLine(formatted) {
+    process.stdout.write(`${formatted}
+`);
+    this.emitLogLine?.(formatted);
+  }
   notifyOutput() {
     for (const cb of this.outputCallbacks)
       cb();
@@ -27782,10 +27785,11 @@ function buildLogPrefix(context4) {
 function resolveModelId(model) {
   return model ? resolveCursorSdkModel(model) : DEFAULT_MODEL;
 }
-function writeSpawnError(logPrefix, err) {
-  const reason = formatCursorSdkLoadError(err);
-  process.stderr.write(`${logPrefix} spawn-error] ${reason}
+function writeSpawnError(logPrefix, err, emitLogLine) {
+  const line = `${logPrefix} spawn-error] ${formatCursorSdkLoadError(err)}`;
+  process.stderr.write(`${line}
 `);
+  emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
 var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache, _sdkLoadError, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 1e4, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion, CursorSdkAgentService;
@@ -27973,6 +27977,11 @@ ${options.prompt}`;
       const exitCallbacks = [];
       const outputCallbacks = [];
       const agentEndCallbacks = [];
+      const logLineCallbacks = [];
+      const emitLogLine = (line) => {
+        for (const cb of logLineCallbacks)
+          cb(line);
+      };
       const finishExit = (code2, signal) => {
         this.sessions.delete(pid);
         this.deleteProcess(pid);
@@ -27991,7 +28000,8 @@ ${options.prompt}`;
         forceFirstTurn,
         finishExit,
         outputCallbacks,
-        agentEndCallbacks
+        agentEndCallbacks,
+        emitLogLine
       });
       return {
         pid,
@@ -28008,6 +28018,9 @@ ${options.prompt}`;
         },
         onAgentEnd: (cb) => {
           agentEndCallbacks.push(cb);
+        },
+        onLogLine: (cb) => {
+          logLineCallbacks.push(cb);
         }
       };
     }
@@ -28021,7 +28034,8 @@ ${options.prompt}`;
         finishExit,
         entry,
         outputCallbacks,
-        agentEndCallbacks
+        agentEndCallbacks,
+        emitLogLine
       } = args2;
       let exited = false;
       (async () => {
@@ -28038,7 +28052,7 @@ ${options.prompt}`;
               }), SEND_TIMEOUT_MS, "agent.send");
               session.run = run3;
               isFirstTurn = false;
-              const adapter = new CursorSdkStreamAdapter(logPrefix);
+              const adapter = new CursorSdkStreamAdapter(logPrefix, emitLogLine);
               adapter.onOutput(() => {
                 entry.lastOutputAt = Date.now();
                 for (const cb of outputCallbacks)
@@ -28056,7 +28070,7 @@ ${options.prompt}`;
                 }
               } catch (streamErr) {
                 exitCode = 1;
-                writeSpawnError(logPrefix, streamErr);
+                writeSpawnError(logPrefix, streamErr, emitLogLine);
                 break;
               }
               if (session.aborted) {
@@ -28069,14 +28083,16 @@ ${options.prompt}`;
                 result = await withTimeout(run3.wait(), RUN_WAIT_TIMEOUT_MS, "run.wait");
               } catch (waitErr) {
                 exitCode = 1;
-                writeSpawnError(logPrefix, waitErr);
+                writeSpawnError(logPrefix, waitErr, emitLogLine);
                 break;
               }
               adapter.flushPendingOutput();
               if (result.status === "error") {
                 exitCode = 2;
-                process.stderr.write(`${logPrefix} run-error] run ${result.id} failed
+                const runErrorLine = `${logPrefix} run-error] run ${result.id} failed`;
+                process.stderr.write(`${runErrorLine}
 `);
+                emitLogLine(runErrorLine);
                 break;
               }
               const resumePromise = waitForResumeOrAbort(session);
@@ -28092,13 +28108,13 @@ ${options.prompt}`;
               nextPrompt = resumePrompt;
             } catch (turnErr) {
               exitCode = 1;
-              writeSpawnError(logPrefix, turnErr);
+              writeSpawnError(logPrefix, turnErr, emitLogLine);
               break;
             }
           }
         } catch (err) {
           exitCode = 1;
-          writeSpawnError(logPrefix, err);
+          writeSpawnError(logPrefix, err, emitLogLine);
         } finally {
           if (exited)
             return;
@@ -28110,7 +28126,7 @@ ${options.prompt}`;
           finishExit(exitCode, exitSignal);
         }
       })().catch((err) => {
-        writeSpawnError(logPrefix, err);
+        writeSpawnError(logPrefix, err, emitLogLine);
         if (exited)
           return;
         exited = true;
@@ -30181,6 +30197,12 @@ function formatLogLine(options, kind, payload) {
   const ts = options.now ? options.now() : new Date().toISOString();
   return `[${ts}] role:${options.role} ${kind}]${payload ? ` ${payload}` : ""}`;
 }
+function writeLogLine(target, options, kind, payload) {
+  const line = formatLogLine(options, kind, payload);
+  target.write(`${line}
+`);
+  options.onLogLine?.(line);
+}
 function isUsageLimitError(error) {
   if (!error || typeof error !== "object")
     return false;
@@ -30236,8 +30258,7 @@ function startSessionEventForwarder(client4, options) {
           continue;
         if (!sessionStarted) {
           sessionStarted = true;
-          target.write(formatLogLine(options, "session] Started", `role: ${options.role}`) + `
-`);
+          writeLogLine(target, options, "session] Started", `role: ${options.role}`);
         }
         switch (event.type) {
           case "message.part.updated": {
@@ -30246,14 +30267,12 @@ function startSessionEventForwarder(client4, options) {
             if (part?.type === "text") {
               const chunk2 = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
               if (chunk2) {
-                target.write(formatLogLine(options, "text", chunk2) + `
-`);
+                writeLogLine(target, options, "text", chunk2);
               }
             } else if (part?.type === "reasoning") {
               const chunk2 = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
               if (chunk2) {
-                target.write(formatLogLine(options, "thinking", chunk2) + `
-`);
+                writeLogLine(target, options, "thinking", chunk2);
               }
             } else if (part?.type === "tool" && part.tool) {
               let appendInput = function(base, input, tool) {
@@ -30280,8 +30299,7 @@ function startSessionEventForwarder(client4, options) {
               const seenKey = `${callID}:${state}`;
               if (!seenToolStates.has(seenKey)) {
                 seenToolStates.set(seenKey, payload);
-                target.write(formatLogLine(options, "tool: " + part.tool, payload) + `
-`);
+                writeLogLine(target, options, "tool: " + part.tool, payload);
               }
               if (state === "completed" || state === "error") {
                 seenToolStates.delete(seenKey);
@@ -30293,20 +30311,17 @@ function startSessionEventForwarder(client4, options) {
             const props = event.properties;
             const kind = props?.action ?? props?.kind;
             const filePayload = kind ? `${props?.file} (${kind})` : props?.file;
-            target.write(formatLogLine(options, "file", filePayload) + `
-`);
+            writeLogLine(target, options, "file", filePayload);
             break;
           }
           case "session.idle": {
-            target.write(formatLogLine(options, "agent_end") + `
-`);
+            writeLogLine(target, options, "agent_end");
             for (const cb of agentEndCallbacks)
               cb();
             break;
           }
           case "session.compacted": {
-            target.write(formatLogLine(options, "compacted") + `
-`);
+            writeLogLine(target, options, "compacted");
             break;
           }
           case "session.status": {
@@ -30314,8 +30329,7 @@ function startSessionEventForwarder(client4, options) {
             const currentStatus = props?.status?.type;
             if (currentStatus !== lastStatus) {
               lastStatus = currentStatus;
-              target.write(formatLogLine(options, "status", currentStatus) + `
-`);
+              writeLogLine(target, options, "status", currentStatus);
             }
             break;
           }
@@ -30329,11 +30343,9 @@ function startSessionEventForwarder(client4, options) {
             } else if (props?.command) {
               payload += ` [command: ${props.command}]`;
             }
-            errorTarget.write(formatLogLine(options, "error", payload) + `
-`);
+            writeLogLine(errorTarget, options, "error", payload);
             if (isUsageLimitError(err)) {
-              target.write(formatLogLine(options, "agent_end", "reason: usage_limit_reached") + `
-`);
+              writeLogLine(target, options, "agent_end", "reason: usage_limit_reached");
               for (const cb of agentEndCallbacks)
                 cb();
             }
@@ -30345,8 +30357,7 @@ function startSessionEventForwarder(client4, options) {
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      errorTarget.write(formatLogLine(options, "error", message) + `
-`);
+      writeLogLine(errorTarget, options, "error", message);
     } finally {
       doneResolve();
     }
@@ -30502,8 +30513,12 @@ var init_opencode_sdk_agent_service = __esm(() => {
         baseUrl,
         agentName,
         model,
-        workingDir
+        logLineCallbacks
       } = args2;
+      const emitLogLine = (line) => {
+        for (const lineCb of logLineCallbacks)
+          lineCb(line);
+      };
       const meta = {
         sessionId,
         machineId: context4.machineId,
@@ -30530,10 +30545,11 @@ var init_opencode_sdk_agent_service = __esm(() => {
         });
       }
       if (childProcess.stderr) {
-        childProcess.stderr.on("data", () => {
+        childProcess.stderr.on("data", (chunk2) => {
           entry.lastOutputAt = Date.now();
           for (const cb of outputCallbacks)
             cb();
+          emitLogLine(chunk2.toString());
         });
       }
       return {
@@ -30560,6 +30576,19 @@ var init_opencode_sdk_agent_service = __esm(() => {
         },
         onAgentEnd: (cb) => {
           forwarder?.onAgentEnd(cb);
+        },
+        onLogLine: (cb) => {
+          logLineCallbacks.push(cb);
+        }
+      };
+    }
+    createLogLineEmitter() {
+      const logLineCallbacks = [];
+      return {
+        logLineCallbacks,
+        emitLogLine: (line) => {
+          for (const cb of logLineCallbacks)
+            cb(line);
         }
       };
     }
@@ -30571,6 +30600,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
       const workingDir = session.workingDir;
       const childProcess = this.spawnServeProcess(workingDir);
       const pid = childProcess.pid;
+      if (pid == null) {
+        throw new Error("Failed to spawn opencode serve process");
+      }
       const baseUrl = await waitForListeningUrl(childProcess, {
         timeoutMs: SERVE_STARTUP_TIMEOUT_MS
       }).catch((err) => {
@@ -30579,6 +30611,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       });
       const client4 = createOpencodeClient({ baseUrl });
       let forwarder;
+      const { logLineCallbacks, emitLogLine } = this.createLogLineEmitter();
       try {
         const sessionInfo = await withTimeout2(client4.session.get({ path: { id: sessionId } }), SESSION_GET_TIMEOUT_MS, "session.get");
         if (!sessionInfo.data?.id) {
@@ -30586,7 +30619,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
         }
         forwarder = startSessionEventForwarder(client4, {
           sessionId,
-          role: context4.role
+          role: context4.role,
+          onLogLine: emitLogLine
         });
         const agentsResponse = await withTimeout2(client4.app.agents(), AGENTS_LIST_TIMEOUT_MS, "app.agents");
         const availableAgents = agentsResponse.data ?? [];
@@ -30624,13 +30658,17 @@ var init_opencode_sdk_agent_service = __esm(() => {
         baseUrl,
         agentName,
         model: modelForSession,
-        workingDir
+        workingDir,
+        logLineCallbacks
       });
     }
     async spawn(options) {
       const { prompt, systemPrompt, model, context: context4 } = options;
       const childProcess = this.spawnServeProcess(options.workingDir);
       const pid = childProcess.pid;
+      if (pid == null) {
+        throw new Error("Failed to spawn opencode serve process");
+      }
       const baseUrl = await waitForListeningUrl(childProcess, {
         timeoutMs: SERVE_STARTUP_TIMEOUT_MS
       }).catch((err) => {
@@ -30643,6 +30681,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
       let sessionId;
       let forwarder;
       let agentName;
+      const { logLineCallbacks, emitLogLine } = this.createLogLineEmitter();
       try {
         const sessionCreateResult = await withTimeout2(client4.session.create({ body: {} }), SESSION_CREATE_TIMEOUT_MS, "session.create");
         if (!sessionCreateResult.data?.id) {
@@ -30651,7 +30690,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
         sessionId = sessionCreateResult.data.id;
         forwarder = startSessionEventForwarder(client4, {
           sessionId,
-          role: context4.role
+          role: context4.role,
+          onLogLine: emitLogLine
         });
         const agentsResponse = await withTimeout2(client4.app.agents(), AGENTS_LIST_TIMEOUT_MS, "app.agents");
         const availableAgents = agentsResponse.data ?? [];
@@ -30683,6 +30723,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
           this.sessionStore.remove(sessionId);
         throw err;
       }
+      if (!sessionId || !agentName) {
+        throw new Error("OpenCode session was not initialized");
+      }
       return this.registerRunningSession({
         childProcess,
         pid,
@@ -30692,7 +30735,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
         baseUrl,
         agentName,
         model,
-        workingDir: options.workingDir
+        workingDir: options.workingDir,
+        logLineCallbacks
       });
     }
     getHarnessReconnectContext(pid) {
@@ -31402,11 +31446,15 @@ This ensures you never forget to pass control back — just copy the command fro
 
 ### Command Reference
 
+**Production (default):** omit \`CHATROOM_CONVEX_URL\` — the CLI connects to chatroom cloud automatically. Do not look up the Convex URL from \`.env\`.
+
 | Action | Command |
 |--------|---------|
-| Fetch next task | \`CHATROOM_CONVEX_URL=<endpoint> chatroom get-next-task --chatroom-id=<id> --role=<role>\` |
-| Pass control | \`CHATROOM_CONVEX_URL=<endpoint> chatroom handoff --chatroom-id=<id> --role=<role> --next-role=<role>\` |
-| Refresh system prompt (after compaction) | \`CHATROOM_CONVEX_URL=<endpoint> chatroom get-system-prompt --chatroom-id=<id> --role=<role>\` |
+| Fetch next task | \`chatroom get-next-task --chatroom-id=<id> --role=<role>\` |
+| Pass control | \`chatroom handoff --chatroom-id=<id> --role=<role> --next-role=<role>\` |
+| Refresh system prompt (after compaction) | \`chatroom get-system-prompt --chatroom-id=<id> --role=<role>\` |
+
+**Non-production only** (local dev, preview): prefix commands with \`CHATROOM_CONVEX_URL=<convex-url> \` (e.g. \`CHATROOM_CONVEX_URL=http://127.0.0.1:3210 chatroom get-next-task ...\`).
 
 ### Context Recovery
 
@@ -80735,6 +80783,7 @@ var init_command_runner = __esm(() => {
 // src/events/lifecycle/on-daemon-shutdown.ts
 async function onDaemonShutdown(ctx) {
   await shutdownAllCommands(ctx);
+  await ctx.deps.agentProcessManager.whenTurnEndsIdle();
   const activeAgents = ctx.deps.agentProcessManager.listActive();
   if (activeAgents.length > 0) {
     console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s)...`);
@@ -85370,66 +85419,6 @@ var init_crash_loop_tracker = __esm(() => {
   ];
 });
 
-// src/infrastructure/deps/process.ts
-function isProcessAlive(kill, pid) {
-  try {
-    kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/domain/agent-lifecycle/entities/stop-reason.ts
-function resolveStopReason(code2, signal) {
-  if (signal !== null)
-    return "agent_process.signal";
-  if (code2 === 0)
-    return "agent_process.exited_clean";
-  return "agent_process.crashed";
-}
-
-// src/domain/agent-lifecycle/policies/preserve-session.ts
-function shouldRetainHarnessSessionForReconnect(reason) {
-  switch (reason) {
-    case "user.stop":
-    case "agent_process.exited_clean":
-    case "agent_process.signal":
-    case "agent_process.crashed":
-      return true;
-    default:
-      return false;
-  }
-}
-function shouldPreserveHarnessTeardown(reason, supportsSessionResume, hasHarnessSessionId) {
-  return hasHarnessSessionId && supportsSessionResume && shouldRetainHarnessSessionForReconnect(reason);
-}
-
-// src/domain/agent-lifecycle/policies/decide-resume-path.ts
-function decideResumePathOnRestart(input) {
-  if (!input.supportsSessionResume) {
-    return "cold";
-  }
-  if (input.wantResume && input.hasStoredSnapshot) {
-    return "daemon_memory";
-  }
-  return "cold";
-}
-function shouldAutoRestartAfterProcessExit(stopReason) {
-  switch (stopReason) {
-    case "user.stop":
-    case "platform.team_switch":
-    case "daemon.shutdown":
-    case "daemon.respawn":
-      return false;
-    default:
-      return true;
-  }
-}
-
-// src/domain/agent-lifecycle/index.ts
-var init_agent_lifecycle = () => {};
-
 // ../../services/backend/src/domain/entities/harness/claude.config.ts
 var claudeCapabilities;
 var init_claude_config = __esm(() => {
@@ -85584,6 +85573,273 @@ var init_types = __esm(() => {
   };
 });
 
+// src/infrastructure/services/agent-process-manager/turn-completed-backend.ts
+function createTurnCompletedBackend(deps) {
+  return {
+    emitResumeStormAborted: (args2) => deps.backend.mutation(api.agentResumeStorm.emitResumeStormAborted, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      ...args2
+    }),
+    emitSessionResumed: (args2) => deps.backend.mutation(api.machines.emitSessionResumed, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      ...args2
+    }),
+    emitSessionResumeFailed: (args2) => deps.backend.mutation(api.machines.emitSessionResumeFailed, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      ...args2
+    })
+  };
+}
+var init_turn_completed_backend = __esm(() => {
+  init_api3();
+});
+
+// src/infrastructure/services/agent-process-manager/turn-end-queue.ts
+class TurnEndQueue {
+  tail = Promise.resolve();
+  enqueue(work) {
+    this.tail = this.tail.then(work).catch((err) => {
+      console.log(`[TurnEndQueue] turn-end handler failed: ${err.message}`);
+    });
+  }
+  async whenIdle() {
+    await this.tail;
+  }
+}
+
+// src/domain/agent-lifecycle/entities/stop-reason.ts
+function resolveStopReason(code2, signal) {
+  if (signal !== null)
+    return "agent_process.signal";
+  if (code2 === 0)
+    return "agent_process.exited_clean";
+  return "agent_process.crashed";
+}
+
+// src/domain/agent-lifecycle/policies/preserve-session.ts
+function shouldRetainHarnessSessionForReconnect(reason) {
+  switch (reason) {
+    case "user.stop":
+    case "agent_process.exited_clean":
+    case "agent_process.signal":
+    case "agent_process.crashed":
+      return true;
+    default:
+      return false;
+  }
+}
+function shouldPreserveHarnessTeardown(reason, supportsSessionResume, hasHarnessSessionId) {
+  return hasHarnessSessionId && supportsSessionResume && shouldRetainHarnessSessionForReconnect(reason);
+}
+
+// src/domain/agent-lifecycle/policies/decide-resume-path.ts
+function decideResumePathOnRestart(input) {
+  if (!input.supportsSessionResume) {
+    return "cold";
+  }
+  if (input.wantResume && input.hasStoredSnapshot) {
+    return "daemon_memory";
+  }
+  return "cold";
+}
+function shouldAutoRestartAfterProcessExit(stopReason) {
+  return !NO_AUTO_RESTART_STOP_REASONS.has(stopReason);
+}
+var NO_AUTO_RESTART_STOP_REASONS;
+var init_decide_resume_path = __esm(() => {
+  NO_AUTO_RESTART_STOP_REASONS = new Set([
+    "user.stop",
+    "platform.team_switch",
+    "platform.resume_storm",
+    "daemon.shutdown",
+    "daemon.respawn"
+  ]);
+});
+
+// src/domain/agent-lifecycle/index.ts
+var init_agent_lifecycle = __esm(() => {
+  init_decide_resume_path();
+});
+
+// src/domain/agent-lifecycle/policies/append-recent-log-line.ts
+function appendRecentLogLine(slot, line) {
+  if (!slot.recentLogLines) {
+    slot.recentLogLines = [];
+  }
+  slot.recentLogLines.push(line);
+  if (slot.recentLogLines.length > RECENT_LOG_LINE_CAP) {
+    slot.recentLogLines.shift();
+  }
+}
+var RECENT_LOG_LINE_CAP = 100;
+
+// src/domain/agent-lifecycle/policies/classify-resume-storm-reason.ts
+function classifyResumeStormReason(logLines) {
+  const blob = logLines.join(`
+`);
+  if (!blob.trim()) {
+    return "unknown";
+  }
+  for (const rule of CLASSIFICATION_RULES) {
+    if (rule.patterns.some((pattern) => pattern.test(blob))) {
+      return rule.reason;
+    }
+  }
+  return "unknown";
+}
+var CLASSIFICATION_RULES;
+var init_classify_resume_storm_reason = __esm(() => {
+  CLASSIFICATION_RULES = [
+    {
+      reason: "rate_limit",
+      patterns: [
+        /\b429\b/,
+        /rate.?limit/i,
+        /too many requests/i,
+        /quota exceeded/i,
+        /usage.?limit/i,
+        /tokens per minute/i
+      ]
+    },
+    {
+      reason: "auth_error",
+      patterns: [
+        /\b401\b/,
+        /\b403\b/,
+        /unauthorized/i,
+        /unauthenticated/i,
+        /authentication failed/i,
+        /invalid.{0,24}api.{0,12}key/i,
+        /api key.{0,20}(invalid|missing|expired)/i
+      ]
+    },
+    {
+      reason: "config_error",
+      patterns: [
+        /model not found/i,
+        /invalid model/i,
+        /missing model/i,
+        /config(uration)? error/i,
+        /ENOENT.{0,40}(config|\.env)/i,
+        /no such file.{0,40}(config|credentials)/i
+      ]
+    }
+  ];
+});
+
+// src/domain/agent-lifecycle/policies/abort-resume-storm.ts
+async function tryAbortResumeStorm(deps, input, slot) {
+  const stormCheck = deps.resumeStormTracker.record(input.chatroomId, input.role, deps.now());
+  if (!stormCheck.isStorm) {
+    return false;
+  }
+  deps.resumeStormTracker.reset(input.chatroomId, input.role);
+  if (slot) {
+    slot.resumeInFlight = false;
+  }
+  try {
+    await deps.backend.emitResumeStormAborted({
+      chatroomId: input.chatroomId,
+      role: input.role,
+      reason: classifyResumeStormReason(slot?.recentLogLines ?? []),
+      endCount: stormCheck.endCount,
+      windowMs: stormCheck.windowMs,
+      ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
+    });
+  } catch {}
+  if (slot?.state === "running" && slot.pid === input.pid) {
+    await deps.stopAgent({
+      chatroomId: input.chatroomId,
+      role: input.role,
+      reason: "platform.resume_storm"
+    });
+  }
+  return true;
+}
+var init_abort_resume_storm = __esm(() => {
+  init_classify_resume_storm_reason();
+});
+
+// src/domain/agent-lifecycle/use-cases/handle-turn-completed.ts
+async function handleTurnCompleted(deps, input, slot) {
+  if (slot?.resumeInFlight) {
+    return { outcome: "skipped_duplicate" };
+  }
+  if (await tryAbortResumeStorm(deps, input, slot)) {
+    return { outcome: "storm_aborted" };
+  }
+  if (input.supportsSessionResume) {
+    if (slot) {
+      slot.resumeInFlight = true;
+    }
+    try {
+      await deps.resumeTurn(input.pid, deps.composeResumePrompt({ chatroomId: input.chatroomId, role: input.role }));
+      try {
+        await deps.backend.emitSessionResumed({
+          chatroomId: input.chatroomId,
+          role: input.role,
+          ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
+        });
+      } catch {}
+      return { outcome: "resumed" };
+    } catch (err) {
+      try {
+        await deps.backend.emitSessionResumeFailed({
+          chatroomId: input.chatroomId,
+          role: input.role,
+          reason: err.message,
+          ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
+        });
+      } catch {}
+    } finally {
+      if (slot) {
+        slot.resumeInFlight = false;
+      }
+    }
+  }
+  deps.killProcess(input.pid);
+  return { outcome: "killed" };
+}
+var init_handle_turn_completed = __esm(() => {
+  init_abort_resume_storm();
+});
+
+// src/infrastructure/deps/process.ts
+function isProcessAlive(kill, pid) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/infrastructure/machine/rapid-resume-tracker.ts
+class RapidResumeTracker {
+  history = new Map;
+  record(chatroomId, role, now = Date.now()) {
+    const key = `${chatroomId}:${role.toLowerCase()}`;
+    const windowStart = now - RAPID_RESUME_WINDOW_MS;
+    const recent = (this.history.get(key) ?? []).filter((ts) => ts >= windowStart);
+    recent.push(now);
+    this.history.set(key, recent);
+    return {
+      isStorm: recent.length >= RAPID_RESUME_THRESHOLD,
+      recentEnds: recent,
+      endCount: recent.length,
+      windowMs: RAPID_RESUME_WINDOW_MS,
+      threshold: RAPID_RESUME_THRESHOLD
+    };
+  }
+  reset(chatroomId, role) {
+    this.history.delete(`${chatroomId}:${role.toLowerCase()}`);
+  }
+}
+var RAPID_RESUME_WINDOW_MS = 30000, RAPID_RESUME_THRESHOLD = 5;
+
 // src/infrastructure/services/remote-agents/spawn-prompt.ts
 function createSpawnPrompt(raw) {
   const trimmed = raw?.trim();
@@ -85602,8 +85858,15 @@ class AgentProcessManager {
   lastHarnessSessions = new Map;
   exitRetryQueue = [];
   exitRetryTimer = null;
+  turnEndQueue = new TurnEndQueue;
   constructor(deps) {
-    this.deps = deps;
+    this.deps = {
+      ...deps,
+      resumeStormTracker: deps.resumeStormTracker ?? new RapidResumeTracker
+    };
+  }
+  async whenTurnEndsIdle() {
+    await this.turnEndQueue.whenIdle();
   }
   async ensureRunning(opts) {
     const key = agentKey2(opts.chatroomId, opts.role);
@@ -85672,67 +85935,46 @@ class AgentProcessManager {
     await operation;
     return { success: true };
   }
-  async handleAgentEnd(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
-    const slot = this.slots.get(key);
-    if (slot?.resumeInFlight) {
-      console.log(`[AgentProcessManager] lifecycle.turn.completed: skipping duplicate resume for ${opts.role} (resume already in flight)`);
-      return;
-    }
+  async runHandleAgentEnd(opts) {
+    const slot = this.slots.get(agentKey2(opts.chatroomId, opts.role));
+    const service = this.deps.agentServices.get(opts.harness);
     const capabilities = getHarnessCapabilities(opts.harness);
-    console.log(`[AgentProcessManager] lifecycle.turn.completed: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${capabilities.supportsSessionResume}`);
-    if (capabilities.supportsSessionResume) {
-      const service = this.deps.agentServices.get(opts.harness);
-      if (service?.resumeTurn) {
-        if (slot) {
-          slot.resumeInFlight = true;
+    const supportsSessionResume = capabilities.supportsSessionResume && typeof service?.resumeTurn === "function";
+    console.log(`[AgentProcessManager] lifecycle.turn.completed: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${supportsSessionResume}`);
+    const result = await handleTurnCompleted({
+      resumeStormTracker: this.deps.resumeStormTracker,
+      backend: createTurnCompletedBackend(this.deps),
+      now: () => this.deps.clock.now(),
+      composeResumePrompt: ({ chatroomId, role }) => composeResumeMessage({
+        chatroomId,
+        role,
+        convexUrl: this.deps.convexUrl
+      }),
+      resumeTurn: async (pid, prompt) => {
+        if (!service?.resumeTurn) {
+          throw new Error("Harness does not support resumeTurn");
         }
+        await service.resumeTurn(pid, prompt);
+      },
+      killProcess: (pid) => {
         try {
-          const resumePrompt = composeResumeMessage({
-            chatroomId: opts.chatroomId,
-            role: opts.role,
-            convexUrl: this.deps.convexUrl
-          });
-          await service.resumeTurn(opts.pid, resumePrompt);
-          try {
-            await this.deps.backend.mutation(api.machines.emitSessionResumed, {
-              sessionId: this.deps.sessionId,
-              machineId: this.deps.machineId,
-              chatroomId: opts.chatroomId,
-              role: opts.role,
-              ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
-            });
-            console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumed for ${opts.role}`);
-          } catch (err) {
-            console.log(`   ⚠️  Failed to emit sessionResumed event: ${err.message}`);
-          }
-          return;
-        } catch (err) {
-          const reason = err.message;
-          try {
-            await this.deps.backend.mutation(api.machines.emitSessionResumeFailed, {
-              sessionId: this.deps.sessionId,
-              machineId: this.deps.machineId,
-              chatroomId: opts.chatroomId,
-              role: opts.role,
-              reason,
-              ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
-            });
-            console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumeFailed for ${opts.role}`);
-          } catch (emitErr) {
-            console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${emitErr.message}`);
-          }
-          console.log(`[AgentProcessManager] ⚠️  resumeTurn failed for ${opts.role} (pid ${opts.pid}): ${reason} — falling back to kill`);
-        } finally {
-          if (slot) {
-            slot.resumeInFlight = false;
-          }
-        }
-      }
+          this.deps.processes.kill(-pid, "SIGTERM");
+        } catch {}
+      },
+      stopAgent: (args2) => this.stop(args2)
+    }, {
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      pid: opts.pid,
+      supportsSessionResume
+    }, slot);
+    if (result.outcome === "skipped_duplicate") {
+      console.log(`[AgentProcessManager] lifecycle.turn.completed: skipping duplicate resume for ${opts.role} (resume already in flight)`);
+    } else if (result.outcome === "storm_aborted") {
+      console.log(`[AgentProcessManager] ✅ Handled rapid resume storm for ${opts.role}`);
+    } else if (result.outcome === "resumed") {
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumed for ${opts.role}`);
     }
-    try {
-      this.deps.processes.kill(-opts.pid, "SIGTERM");
-    } catch {}
   }
   async handleExit(opts) {
     const key = agentKey2(opts.chatroomId, opts.role);
@@ -85853,18 +86095,11 @@ class AgentProcessManager {
           signal: undefined,
           agentHarness: entry.harness
         };
-        this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
-          console.log(`   ⚠️  Failed to record agent exit on recovery: ${err.message}`);
-          this.queueExitRetry({ role, args: exitArgs });
-        });
-        try {
-          await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
-        } catch {}
+        this.recordAgentExitedOrQueueRetry(role, exitArgs, "Failed to record agent exit on recovery");
+        await this.clearAgentPidQuietly(chatroomId, role);
         killed++;
       } else {
-        try {
-          await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
-        } catch {}
+        await this.clearAgentPidQuietly(chatroomId, role);
         cleaned++;
       }
     }
@@ -85936,13 +86171,8 @@ class AgentProcessManager {
       signal: undefined,
       agentHarness: harness
     };
-    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
-      console.log(`   ⚠️  Failed to record agent exit before respawn: ${err.message}`);
-      this.queueExitRetry({ role, args: exitArgs });
-    });
-    try {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
-    } catch {}
+    this.recordAgentExitedOrQueueRetry(role, exitArgs, "Failed to record agent exit before respawn");
+    await this.clearAgentPidQuietly(chatroomId, role);
   }
   async executeEnsureRunning(key, slot, opts) {
     try {
@@ -85962,6 +86192,17 @@ class AgentProcessManager {
       }
     }
   }
+  recordAgentExitedOrQueueRetry(role, exitArgs, failureLog) {
+    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs).catch((err) => {
+      console.log(`   ⚠️  ${failureLog}: ${err.message}`);
+      this.queueExitRetry({ role, args: exitArgs });
+    });
+  }
+  async clearAgentPidQuietly(chatroomId, role) {
+    try {
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+    } catch {}
+  }
   queueExitRetry(item) {
     this.exitRetryQueue.push(item);
     if (this.exitRetryTimer === null) {
@@ -86205,6 +86446,11 @@ class AgentProcessManager {
       slot.workingDir = opts.workingDir;
       slot.startedAt = this.deps.clock.now();
       slot.pendingOperation = undefined;
+      slot.recentLogLines = [];
+      this.deps.resumeStormTracker.reset(opts.chatroomId, opts.role);
+      if (spawnResult.onLogLine) {
+        spawnResult.onLogLine((line) => appendRecentLogLine(slot, line));
+      }
       this.deps.backend.mutation(api.machines.updateSpawnedAgent, {
         sessionId: this.deps.sessionId,
         machineId: this.deps.machineId,
@@ -86231,12 +86477,12 @@ class AgentProcessManager {
       });
       if (spawnResult.onAgentEnd) {
         spawnResult.onAgentEnd(() => {
-          this.handleAgentEnd({
+          this.turnEndQueue.enqueue(() => this.runHandleAgentEnd({
             chatroomId: opts.chatroomId,
             role: opts.role,
             pid,
             harness: opts.agentHarness
-          });
+          }));
         });
       }
       let lastReportedTokenAt = 0;
@@ -86348,11 +86594,13 @@ class AgentProcessManager {
 }
 var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
 var init_agent_process_manager = __esm(() => {
-  init_orphan_tracker();
+  init_generator();
+  init_types();
+  init_turn_completed_backend();
   init_api3();
+  init_orphan_tracker();
   init_agent_lifecycle();
-  init_types();
-  init_generator();
+  init_handle_turn_completed();
 });
 
 // src/infrastructure/services/harness-spawning/rate-limiter.ts
@@ -88578,4 +88826,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=A45EE098A894A8F164756E2164756E21
+//# debugId=A9CDF253A2BBC68F64756E2164756E21