chatroom-cli 1.11.0 → 1.11.2

package/dist/index.js

@@ -11134,34 +11134,10 @@ var init_daemon_state = __esm(() => {
   STATE_DIR = join4(CHATROOM_DIR3, "machines", "state");
 });
 
-// src/infrastructure/machine/intentional-stops.ts
-function agentKey2(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
-}
-function markIntentionalStop(chatroomId, role, reason = "user.stop") {
-  pendingStops.set(agentKey2(chatroomId, role), reason);
-}
-function consumeIntentionalStop(chatroomId, role) {
-  const key = agentKey2(chatroomId, role);
-  const reason = pendingStops.get(key) ?? null;
-  if (reason !== null) {
-    pendingStops.delete(key);
-  }
-  return reason;
-}
-function clearIntentionalStop(chatroomId, role) {
-  pendingStops.delete(agentKey2(chatroomId, role));
-}
-var pendingStops;
-var init_intentional_stops = __esm(() => {
-  pendingStops = new Map;
-});
-
 // src/infrastructure/machine/index.ts
 var init_machine = __esm(() => {
   init_storage2();
   init_daemon_state();
-  init_intentional_stops();
 });
 
 // src/commands/auth-status/index.ts
@@ -14285,11 +14261,16 @@ function formatTimestamp() {
   return new Date().toISOString().replace("T", " ").substring(0, 19);
 }
 
+// src/commands/machine/daemon-start/types.ts
+function agentKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+
 // src/events/lifecycle/on-agent-shutdown.ts
 async function onAgentShutdown(ctx, options) {
   const { chatroomId, role, pid, skipKill } = options;
   try {
-    ctx.deps.stops.mark(chatroomId, role, options.stopReason ?? "user.stop");
+    ctx.pendingStops.set(agentKey2(chatroomId, role), options.stopReason ?? "user.stop");
   } catch (e) {
     console.log(`   ⚠️  Failed to mark intentional stop for ${role}: ${e.message}`);
   }
@@ -14349,6 +14330,7 @@ async function onAgentShutdown(ctx, options) {
     cleaned: killed || (skipKill ?? false)
   };
 }
+var init_on_agent_shutdown = () => {};
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 async function onDaemonShutdown(ctx) {
@@ -14389,6 +14371,7 @@ async function onDaemonShutdown(ctx) {
 var AGENT_SHUTDOWN_TIMEOUT_MS = 5000;
 var init_on_daemon_shutdown = __esm(() => {
   init_api3();
+  init_on_agent_shutdown();
 });
 
 // src/commands/machine/daemon-start/handlers/shared.ts
@@ -14675,12 +14658,12 @@ class DaemonEventBus {
 
 // src/events/daemon/agent/on-agent-exited.ts
 function onAgentExited(ctx, payload) {
-  const { chatroomId, role, pid, code: code2, signal, stopReason, intentional } = payload;
+  const { chatroomId, role, pid, code: code2, signal, stopReason } = payload;
   const ts = formatTimestamp();
   console.log(`[${ts}] Agent stopped: ${stopReason} (${role})`);
   const isDaemonRespawn = stopReason === "daemon.respawn";
-  const isIntentional = intentional && !isDaemonRespawn;
-  if (isIntentional) {
+  const isIntentional = stopReason === "user.stop" || stopReason === "platform.team_switch" || stopReason === "agent_process.turn_end" || stopReason === "agent_process.turn_end_quick_fail";
+  if (isIntentional && !isDaemonRespawn) {
     console.log(`[${ts}] ℹ️  Agent process exited after intentional stop ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
   } else if (isDaemonRespawn) {
     console.log(`[${ts}] \uD83D\uDD04  Agent process stopped for respawn ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
@@ -14693,11 +14676,11 @@ function onAgentExited(ctx, payload) {
     chatroomId,
     role,
     pid,
-    intentional,
     stopReason,
     stopSignal: stopReason === "agent_process.signal" ? signal ?? undefined : undefined,
     exitCode: code2 ?? undefined,
-    signal: signal ?? undefined
+    signal: signal ?? undefined,
+    agentHarness: payload.agentHarness
   }).catch((err) => {
     console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
   });
@@ -14773,11 +14756,6 @@ function createDefaultDeps19() {
     fs: {
       stat
     },
-    stops: {
-      mark: markIntentionalStop,
-      consume: consumeIntentionalStop,
-      clear: clearIntentionalStop
-    },
     machine: {
       clearAgentPid,
       persistAgentPid,
@@ -14908,7 +14886,8 @@ async function initDaemon() {
     events,
     agentServices,
     activeWorkingDirs: new Set,
-    lastPushedGitState: new Map
+    lastPushedGitState: new Map,
+    pendingStops: new Map
   };
   registerEventListeners(ctx);
   logStartup(ctx, availableModels);
@@ -14921,7 +14900,6 @@ var init_init2 = __esm(() => {
   init_storage();
   init_client2();
   init_machine();
-  init_intentional_stops();
   init_remote_agents();
   init_harness_spawning();
   init_error_formatting();
@@ -15030,6 +15008,7 @@ async function executeStartAgent(ctx, args) {
     return { result: msg2, failed: true };
   }
   const { pid } = spawnResult;
+  const spawnedAt = Date.now();
   const msg = `Agent spawned (PID: ${pid})`;
   console.log(`   ✅ ${msg}`);
   ctx.deps.spawning.recordSpawn(chatroomId);
@@ -15058,7 +15037,11 @@ async function executeStartAgent(ctx, args) {
   ctx.activeWorkingDirs.add(workingDir);
   spawnResult.onExit(({ code: code2, signal }) => {
     ctx.deps.spawning.recordExit(chatroomId);
-    const pendingReason = ctx.deps.stops.consume(chatroomId, role);
+    const key = agentKey2(chatroomId, role);
+    const pendingReason = ctx.pendingStops.get(key) ?? null;
+    if (pendingReason) {
+      ctx.pendingStops.delete(key);
+    }
     const stopReason = pendingReason ?? resolveStopReason(code2, signal, false);
     ctx.events.emit("agent:exited", {
       chatroomId,
@@ -15067,11 +15050,16 @@ async function executeStartAgent(ctx, args) {
       code: code2,
       signal,
       stopReason,
-      intentional: pendingReason !== null
+      agentHarness
     });
   });
   if (spawnResult.onAgentEnd) {
     spawnResult.onAgentEnd(() => {
+      const elapsed = Date.now() - spawnedAt;
+      const isHealthyTurn = elapsed >= MIN_HEALTHY_TURN_MS;
+      const stopReason = isHealthyTurn ? "agent_process.turn_end" : "agent_process.turn_end_quick_fail";
+      const key = agentKey2(chatroomId, role);
+      ctx.pendingStops.set(key, stopReason);
       try {
         ctx.deps.processes.kill(-pid, "SIGTERM");
       } catch {}
@@ -15091,23 +15079,27 @@ async function executeStartAgent(ctx, args) {
   });
   return { result: msg, failed: false };
 }
+var MIN_HEALTHY_TURN_MS = 30000;
 var init_start_agent = __esm(() => {
   init_api3();
   init_client2();
+  init_on_agent_shutdown();
 });
 
 // src/events/daemon/agent/on-request-start-agent.ts
 async function onRequestStartAgent(ctx, event) {
+  const eventId = event._id.toString();
   if (Date.now() > event.deadline) {
-    console.log(`[daemon] ⏰ Skipping expired agent.requestStart for role=${event.role} (deadline passed)`);
+    console.log(`[daemon] ⏰ Skipping expired agent.requestStart for role=${event.role} (id: ${eventId}, deadline passed)`);
     return;
   }
   const spawnCheck = ctx.deps.spawning.shouldAllowSpawn(event.chatroomId, event.reason);
   if (!spawnCheck.allowed) {
     const retryMsg = spawnCheck.retryAfterMs ? ` Retry after ${spawnCheck.retryAfterMs}ms.` : "";
-    console.warn(`[daemon] ⚠️  Spawn suppressed for chatroom=${event.chatroomId} role=${event.role} reason=${event.reason}.${retryMsg}`);
+    console.warn(`[daemon] ⚠️  Spawn suppressed for chatroom=${event.chatroomId} role=${event.role} reason=${event.reason} (id: ${eventId}).${retryMsg}`);
     return;
   }
+  console.log(`[daemon] Processing agent.requestStart (id: ${eventId})`);
   await executeStartAgent(ctx, {
     chatroomId: event.chatroomId,
     role: event.role,
@@ -15196,6 +15188,7 @@ async function executeStopAgent(ctx, args) {
 }
 var init_stop_agent = __esm(() => {
   init_api3();
+  init_on_agent_shutdown();
   init_shared();
 });
 
@@ -15729,6 +15722,162 @@ var init_git_heartbeat = __esm(() => {
   init_git_polling();
 });
 
+// src/infrastructure/services/remote-agents/harness-restart-policy.ts
+class OpenCodeRestartPolicy {
+  id = "opencode";
+  shouldStartAgent(params) {
+    const { task, agentConfig } = params;
+    if (agentConfig.desiredState !== "running") {
+      return false;
+    }
+    if (agentConfig.circuitState === "open") {
+      return false;
+    }
+    if (task.status === "in_progress") {
+      return agentConfig.spawnedAgentPid == null;
+    }
+    if (task.status === "pending" || task.status === "acknowledged") {
+      return agentConfig.spawnedAgentPid == null;
+    }
+    return false;
+  }
+}
+
+class PiRestartPolicy {
+  id = "pi";
+  shouldStartAgent(params, context) {
+    const { task, agentConfig } = params;
+    if (agentConfig.desiredState !== "running") {
+      return false;
+    }
+    if (agentConfig.circuitState === "open") {
+      return false;
+    }
+    if (task.status === "in_progress") {
+      return agentConfig.spawnedAgentPid == null;
+    }
+    if (task.status === "pending" || task.status === "acknowledged") {
+      if (agentConfig.spawnedAgentPid == null) {
+        return true;
+      }
+    }
+    if (task.status !== "pending" && task.status !== "acknowledged") {
+      return false;
+    }
+    if (!context?.pendingStops) {
+      return false;
+    }
+    const key = `${task.chatroomId}:${agentConfig.role.toLowerCase()}`;
+    const pendingReason = context.pendingStops.get(key);
+    return pendingReason === "agent_process.turn_end";
+  }
+}
+function getRestartPolicyForHarness(harness) {
+  switch (harness) {
+    case "opencode":
+      return new OpenCodeRestartPolicy;
+    case "pi":
+      return new PiRestartPolicy;
+    default:
+      return {
+        id: harness,
+        shouldStartAgent: () => false
+      };
+  }
+}
+
+// src/commands/machine/daemon-start/task-monitor.ts
+function canAttemptRestart(chatroomId, role, now) {
+  const key = `${chatroomId}:${role.toLowerCase()}`;
+  const lastAttempt = lastRestartAttempt.get(key) ?? 0;
+  return now - lastAttempt >= RESTART_COOLDOWN_MS;
+}
+function recordRestartAttempt(chatroomId, role, now) {
+  const key = `${chatroomId}:${role.toLowerCase()}`;
+  lastRestartAttempt.set(key, now);
+}
+function startTaskMonitor(ctx) {
+  let unsubscribe = null;
+  let isRunning = true;
+  const startMonitoring = async () => {
+    try {
+      const wsClient2 = await getConvexWsClient();
+      const agentEndContext = {
+        pendingStops: ctx.pendingStops
+      };
+      unsubscribe = wsClient2.onUpdate(api.machines.getAssignedTasks, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId
+      }, async (result) => {
+        if (!result?.tasks || result.tasks.length === 0)
+          return;
+        const now = Date.now();
+        for (const taskInfo of result.tasks) {
+          const { task, agentConfig } = {
+            task: {
+              taskId: taskInfo.taskId,
+              chatroomId: taskInfo.chatroomId,
+              status: taskInfo.status,
+              assignedTo: taskInfo.assignedTo,
+              updatedAt: taskInfo.updatedAt,
+              createdAt: taskInfo.createdAt
+            },
+            agentConfig: taskInfo.agentConfig
+          };
+          const policy = getRestartPolicyForHarness(agentConfig.agentHarness);
+          const shouldStart = policy.shouldStartAgent({ task, agentConfig }, agentEndContext);
+          if (!shouldStart)
+            continue;
+          if (!canAttemptRestart(task.chatroomId, agentConfig.role, now)) {
+            continue;
+          }
+          if (!agentConfig.workingDir) {
+            console.warn(`[${formatTimestamp()}] ⚠️  Missing workingDir for ${task.chatroomId}/${agentConfig.role}` + ` — skipping`);
+            continue;
+          }
+          console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Task monitor: starting agent for ` + `${task.chatroomId}/${agentConfig.role} (harness: ${agentConfig.agentHarness})`);
+          recordRestartAttempt(task.chatroomId, agentConfig.role, now);
+          try {
+            await executeStartAgent(ctx, {
+              chatroomId: task.chatroomId,
+              role: agentConfig.role,
+              agentHarness: agentConfig.agentHarness,
+              model: agentConfig.model,
+              workingDir: agentConfig.workingDir,
+              reason: "daemon.task_monitor"
+            });
+          } catch (err) {
+            console.error(`[${formatTimestamp()}] ❌ Task monitor failed to start agent ` + `for ${task.chatroomId}/${agentConfig.role}: ${err.message}`);
+          }
+        }
+      });
+      console.log(`[${formatTimestamp()}] \uD83D\uDD0D Task monitor started`);
+    } catch (err) {
+      if (isRunning) {
+        console.error(`[${formatTimestamp()}] ❌ Task monitor error: ${err.message}`);
+        setTimeout(startMonitoring, 5000);
+      }
+    }
+  };
+  startMonitoring();
+  return {
+    stop: () => {
+      isRunning = false;
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+    }
+  };
+}
+var RESTART_COOLDOWN_MS = 60000, lastRestartAttempt;
+var init_task_monitor = __esm(() => {
+  init_api3();
+  init_client2();
+  init_start_agent();
+  lastRestartAttempt = new Map;
+});
+
 // src/commands/machine/daemon-start/command-loop.ts
 async function refreshModels(ctx) {
   if (!ctx.config)
@@ -15816,12 +15965,14 @@ async function startCommandLoop(ctx) {
   }, DAEMON_HEARTBEAT_INTERVAL_MS);
   heartbeatTimer.unref();
   const gitPollingHandle = startGitPollingLoop(ctx);
+  const taskMonitorHandle = startTaskMonitor(ctx);
   pushGitState(ctx).catch(() => {});
   const shutdown = async () => {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
     clearInterval(heartbeatTimer);
     gitPollingHandle.stop();
+    taskMonitorHandle.stop();
     await onDaemonShutdown(ctx);
     releaseLock();
     process.exit(0);
@@ -15846,7 +15997,7 @@ Listening for commands...`);
     evictStaleDedupEntries(processedCommandIds, processedPingIds, processedGitRefreshIds);
     for (const event of result.events) {
       try {
-        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
+        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type} (id: ${event._id})`);
         await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds, processedGitRefreshIds);
       } catch (err) {
         console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
@@ -15873,6 +16024,7 @@ var init_command_loop = __esm(() => {
   init_pid();
   init_git_polling();
   init_git_heartbeat();
+  init_task_monitor();
   MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatroom-cli",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {