chatroom-cli 1.10.0 → 1.11.1

package/dist/index.js

@@ -14908,7 +14908,8 @@ async function initDaemon() {
     events,
     agentServices,
     activeWorkingDirs: new Set,
-    lastPushedGitState: new Map
+    lastPushedGitState: new Map,
+    agentEndedTurn: new Map
   };
   registerEventListeners(ctx);
   logStartup(ctx, availableModels);
@@ -15032,6 +15033,8 @@ async function executeStartAgent(ctx, args) {
   const { pid } = spawnResult;
   const msg = `Agent spawned (PID: ${pid})`;
   console.log(`   ✅ ${msg}`);
+  const agentEndKey = `${chatroomId}:${role.toLowerCase()}`;
+  ctx.agentEndedTurn.delete(agentEndKey);
   ctx.deps.spawning.recordSpawn(chatroomId);
   try {
     await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
@@ -15072,6 +15075,7 @@ async function executeStartAgent(ctx, args) {
   });
   if (spawnResult.onAgentEnd) {
     spawnResult.onAgentEnd(() => {
+      ctx.agentEndedTurn.set(agentEndKey, true);
       try {
         ctx.deps.processes.kill(-pid, "SIGTERM");
       } catch {}
@@ -15729,6 +15733,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?.agentEndedTurn) {
+      return false;
+    }
+    const key = `${task.chatroomId}:${agentConfig.role}`;
+    const hasEndedTurn = context.agentEndedTurn.get(key);
+    return hasEndedTurn === true;
+  }
+}
+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 = {
+        agentEndedTurn: ctx.agentEndedTurn
+      };
+      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 +15976,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);
@@ -15873,6 +16035,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.10.0",
+  "version": "1.11.1",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {