chatroom-cli 1.2.3 → 1.2.7

package/dist/index.js

@@ -10371,6 +10371,20 @@ function listAgentEntries(machineId) {
   }
   return results;
 }
+function persistEventCursor(machineId, lastSeenEventId) {
+  try {
+    const state = loadOrCreate(machineId);
+    state.lastSeenEventId = lastSeenEventId;
+    state.updatedAt = new Date().toISOString();
+    saveDaemonState(state);
+  } catch (err) {
+    console.warn(`⚠️  Failed to persist event cursor: ${err.message}`);
+  }
+}
+function loadEventCursor(machineId) {
+  const state = loadDaemonState(machineId);
+  return state?.lastSeenEventId ?? null;
+}
 var CHATROOM_DIR3, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
   CHATROOM_DIR3 = join4(homedir3(), ".chatroom");
@@ -11284,22 +11298,9 @@ async function registerAgent(chatroomId, options, deps) {
         harnessVersions: machineInfo.harnessVersions,
         availableModels
       });
-      const agentHarness = machineInfo.availableHarnesses.length > 0 ? machineInfo.availableHarnesses[0] : undefined;
-      await d.backend.mutation(api.machines.saveTeamAgentConfig, {
-        sessionId,
-        chatroomId,
-        role,
-        type: "remote",
-        machineId: machineInfo.machineId,
-        agentHarness,
-        workingDir: process.cwd()
-      });
       console.log(`✅ Registered as remote agent for role "${role}"`);
       console.log(`   Machine: ${machineInfo.hostname} (${machineInfo.machineId})`);
       console.log(`   Working directory: ${process.cwd()}`);
-      if (agentHarness) {
-        console.log(`   Agent harness: ${agentHarness}`);
-      }
     } catch (error) {
       console.error(`❌ Registration failed: ${error.message}`);
       process.exit(1);
@@ -11327,7 +11328,7 @@ var init_register_agent = __esm(() => {
   init_opencode();
   init_pi();
 });
-// ../../services/backend/prompts/base/cli/task-started/command.ts
+// ../../services/backend/prompts/cli/task-started/command.ts
 function taskStartedCommand(params) {
   const prefix = params.cliEnvPrefix || "";
   const chatroomId = params.chatroomId || "<chatroom-id>";
@@ -11351,22 +11352,22 @@ EOF`;
   return baseCmd;
 }
 
-// ../../services/backend/prompts/base/cli/task-started/classification/new-feature.ts
+// ../../services/backend/prompts/cli/task-started/classification/new-feature.ts
 var init_new_feature = () => {};
-// ../../services/backend/prompts/base/cli/task-started/classification/index.ts
+// ../../services/backend/prompts/cli/task-started/classification/index.ts
 var init_classification = __esm(() => {
   init_new_feature();
 });
-// ../../services/backend/prompts/base/cli/task-started/main-prompt.ts
+// ../../services/backend/prompts/cli/task-started/main-prompt.ts
 var init_main_prompt = () => {};
 
-// ../../services/backend/prompts/base/cli/task-started/index.ts
+// ../../services/backend/prompts/cli/task-started/index.ts
 var init_task_started = __esm(() => {
   init_classification();
   init_main_prompt();
 });
 
-// ../../services/backend/prompts/base/cli/get-next-task/reminder.ts
+// ../../services/backend/prompts/cli/get-next-task/reminder.ts
 function getNextTaskGuidance() {
   return `\uD83D\uDD17 STAYING CONNECTED TO YOUR TEAM
 
@@ -11455,7 +11456,7 @@ var init_getting_started_content = __esm(() => {
   init_utils();
 });
 
-// ../../services/backend/prompts/base/cli/index.ts
+// ../../services/backend/prompts/cli/index.ts
 var init_cli = __esm(() => {
   init_task_started();
   init_reminder();
@@ -11481,7 +11482,7 @@ var init_errorCodes = __esm(() => {
   ];
 });
 
-// ../../services/backend/prompts/base/cli/get-next-task/command.ts
+// ../../services/backend/prompts/cli/get-next-task/command.ts
 function getNextTaskCommand(params) {
   const prefix = params.cliEnvPrefix || "";
   const chatroomId = params.chatroomId || "<chatroom-id>";
@@ -12182,7 +12183,7 @@ function formatDecodeError(error) {
   return message;
 }
 
-// ../../services/backend/prompts/base/cli/handoff/command.ts
+// ../../services/backend/prompts/cli/handoff/command.ts
 function handoffCommand(params) {
   const prefix = params.cliEnvPrefix || "";
   const chatroomId = params.chatroomId || "<chatroom-id>";
@@ -13656,6 +13657,7 @@ async function getSystemPrompt(chatroomId, options, deps) {
     const prompt = await d.backend.query(api.prompts.webapp.getAgentPrompt, {
       chatroomId,
       role,
+      teamId: chatroom.teamId,
       teamName: chatroom.teamName,
       teamRoles: chatroom.teamRoles,
       teamEntryPoint: chatroom.teamEntryPoint,
@@ -13676,56 +13678,14 @@ var init_get_system_prompt = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS = 30000;
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000;
 
 // src/commands/machine/daemon-start/utils.ts
 function formatTimestamp() {
   return new Date().toISOString().replace("T", " ").substring(0, 19);
 }
-function parseMachineCommand(raw) {
-  switch (raw.type) {
-    case "ping":
-      return { _id: raw._id, type: "ping", payload: {}, createdAt: raw.createdAt };
-    case "status":
-      return { _id: raw._id, type: "status", payload: {}, createdAt: raw.createdAt };
-    case "start-agent": {
-      const { chatroomId, role, agentHarness } = raw.payload;
-      if (!chatroomId || !role || !agentHarness) {
-        console.error(`   ⚠️  Invalid start-agent command: missing chatroomId, role, or agentHarness`);
-        return null;
-      }
-      return {
-        _id: raw._id,
-        type: "start-agent",
-        payload: {
-          chatroomId,
-          role,
-          agentHarness,
-          model: raw.payload.model,
-          workingDir: raw.payload.workingDir
-        },
-        createdAt: raw.createdAt
-      };
-    }
-    case "stop-agent": {
-      const { chatroomId, role } = raw.payload;
-      if (!chatroomId || !role) {
-        console.error(`   ⚠️  Invalid stop-agent command: missing chatroomId or role`);
-        return null;
-      }
-      return {
-        _id: raw._id,
-        type: "stop-agent",
-        payload: { chatroomId, role },
-        createdAt: raw.createdAt
-      };
-    }
-    default:
-      return null;
-  }
-}
 
-// src/commands/machine/events/on-agent-shutdown/index.ts
+// src/events/lifecycle/on-agent-shutdown.ts
 async function onAgentShutdown(ctx, options) {
   const { chatroomId, role, pid, skipKill } = options;
   try {
@@ -13784,42 +13744,13 @@ async function onAgentShutdown(ctx, options) {
       console.log(`   ⚠️  Failed to clear local PID for ${role}: ${e.message}`);
     }
   }
-  let spawnedAgentCleared = false;
-  if (killed || skipKill) {
-    try {
-      await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId,
-        chatroomId,
-        role,
-        pid: undefined
-      });
-      spawnedAgentCleared = true;
-    } catch (e) {
-      console.log(`   ⚠️  Failed to clear spawnedAgent for ${role}: ${e.message}`);
-    }
-  }
-  let participantRemoved = false;
-  try {
-    await ctx.deps.backend.mutation(api.participants.leave, {
-      sessionId: ctx.sessionId,
-      chatroomId,
-      role
-    });
-    participantRemoved = true;
-  } catch (e) {
-    console.log(`   ⚠️  Failed to remove participant for ${role}: ${e.message}`);
-  }
   return {
     killed: killed || (skipKill ?? false),
-    cleaned: spawnedAgentCleared && participantRemoved
+    cleaned: killed || (skipKill ?? false)
   };
 }
-var init_on_agent_shutdown = __esm(() => {
-  init_api3();
-});
 
-// src/commands/machine/events/on-daemon-shutdown/index.ts
+// src/events/lifecycle/on-daemon-shutdown.ts
 async function onDaemonShutdown(ctx) {
   const agents = ctx.deps.machine.listAgentEntries(ctx.machineId);
   if (agents.length > 0) {
@@ -13858,108 +13789,18 @@ 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/pid.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
-function getUrlHash() {
-  const url = getConvexUrl();
-  return createHash("sha256").update(url).digest("hex").substring(0, 8);
-}
-function getPidFileName() {
-  return `daemon-${getUrlHash()}.pid`;
-}
-function ensureChatroomDir() {
-  if (!existsSync4(CHATROOM_DIR4)) {
-    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
-  }
-}
-function getPidFilePath() {
-  return join5(CHATROOM_DIR4, getPidFileName());
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readPid() {
-  const pidPath = getPidFilePath();
-  if (!existsSync4(pidPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync6(pidPath, "utf-8").trim();
-    const pid = parseInt(content, 10);
-    if (isNaN(pid) || pid <= 0) {
-      return null;
-    }
-    return pid;
-  } catch {
-    return null;
-  }
-}
-function writePid() {
-  ensureChatroomDir();
-  const pidPath = getPidFilePath();
-  writeFileSync4(pidPath, process.pid.toString(), "utf-8");
-}
-function removePid() {
-  const pidPath = getPidFilePath();
-  try {
-    if (existsSync4(pidPath)) {
-      unlinkSync2(pidPath);
-    }
-  } catch {}
-}
-function isDaemonRunning() {
-  const pid = readPid();
-  if (pid === null) {
-    return { running: false, pid: null };
-  }
-  if (isProcessRunning(pid)) {
-    return { running: true, pid };
-  }
-  removePid();
-  return { running: false, pid: null };
-}
-function acquireLock() {
-  const { running, pid } = isDaemonRunning();
-  if (running) {
-    console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
-    return false;
-  }
-  writePid();
-  return true;
-}
-function releaseLock() {
-  removePid();
-}
-var CHATROOM_DIR4;
-var init_pid = __esm(() => {
-  init_client2();
-  CHATROOM_DIR4 = join5(homedir4(), ".chatroom");
-});
-
-// src/commands/machine/daemon-start/handlers/ping.ts
-function handlePing() {
-  console.log(`   ↪ Responding: pong`);
-  return { result: "pong", failed: false };
-}
-
 // src/commands/machine/daemon-start/handlers/start-agent.ts
-async function handleStartAgent(ctx, command) {
-  const { chatroomId, role, agentHarness, model, workingDir } = command.payload;
+async function executeStartAgent(ctx, args) {
+  const { chatroomId, role, agentHarness, model, workingDir, reason } = args;
   console.log(`   ↪ start-agent command received`);
   console.log(`      Chatroom: ${chatroomId}`);
   console.log(`      Role: ${role}`);
   console.log(`      Harness: ${agentHarness}`);
+  if (reason) {
+    console.log(`      Reason: ${reason}`);
+  }
   if (model) {
     console.log(`      Model: ${model}`);
   }
@@ -13987,14 +13828,19 @@ async function handleStartAgent(ctx, command) {
       chatroomId
     });
     const existingConfig = existingConfigs.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
-    if (existingConfig?.spawnedAgentPid) {
-      const existingPid = existingConfig.spawnedAgentPid;
-      const anyService = ctx.agentServices.values().next().value;
-      const isAlive = anyService ? anyService.isAlive(existingPid) : false;
+    const backendPid = existingConfig?.spawnedAgentPid;
+    const localEntry = ctx.deps.machine.listAgentEntries(ctx.machineId).find((e) => e.chatroomId === chatroomId && e.role.toLowerCase() === role.toLowerCase());
+    const localPid = localEntry?.entry.pid;
+    const pidsToKill = [
+      ...new Set([backendPid, localPid].filter((p) => p !== undefined))
+    ];
+    const anyService = ctx.agentServices.values().next().value;
+    for (const pid2 of pidsToKill) {
+      const isAlive = anyService ? anyService.isAlive(pid2) : false;
       if (isAlive) {
-        console.log(`   ⚠️  Existing agent detected (PID: ${existingPid}) — stopping before respawn`);
-        await onAgentShutdown(ctx, { chatroomId, role, pid: existingPid });
-        console.log(`   ✅ Existing agent stopped`);
+        console.log(`   ⚠️  Existing agent detected (PID: ${pid2}) — stopping before respawn`);
+        await onAgentShutdown(ctx, { chatroomId, role, pid: pid2 });
+        console.log(`   ✅ Existing agent stopped (PID: ${pid2})`);
       }
     }
   } catch (e) {
@@ -14085,19 +13931,26 @@ async function handleStartAgent(ctx, command) {
 var init_start_agent = __esm(() => {
   init_api3();
   init_client2();
-  init_on_agent_shutdown();
 });
 
-// src/commands/machine/daemon-start/handlers/status.ts
-function handleStatus(ctx) {
-  const result = JSON.stringify({
-    hostname: ctx.config?.hostname,
-    os: ctx.config?.os,
-    availableHarnesses: ctx.config?.availableHarnesses
+// src/events/daemon/agent/on-request-start-agent.ts
+async function onRequestStartAgent(ctx, event) {
+  if (Date.now() > event.deadline) {
+    console.log(`[daemon] ⏰ Skipping expired agent.requestStart for role=${event.role} (deadline passed)`);
+    return;
+  }
+  await executeStartAgent(ctx, {
+    chatroomId: event.chatroomId,
+    role: event.role,
+    agentHarness: event.agentHarness,
+    model: event.model,
+    workingDir: event.workingDir,
+    reason: event.reason
   });
-  console.log(`   ↪ Responding with status`);
-  return { result, failed: false };
 }
+var init_on_request_start_agent = __esm(() => {
+  init_start_agent();
+});
 
 // src/commands/machine/daemon-start/handlers/shared.ts
 async function clearAgentPidEverywhere(ctx, chatroomId, role) {
@@ -14119,8 +13972,8 @@ var init_shared = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/handlers/stop-agent.ts
-async function handleStopAgent(ctx, command) {
-  const { chatroomId, role } = command.payload;
+async function executeStopAgent(ctx, args) {
+  const { chatroomId, role } = args;
   console.log(`   ↪ stop-agent command received`);
   console.log(`      Chatroom: ${chatroomId}`);
   console.log(`      Role: ${role}`);
@@ -14129,53 +13982,178 @@ async function handleStopAgent(ctx, command) {
     chatroomId
   });
   const targetConfig = configsResult.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
-  if (!targetConfig?.spawnedAgentPid) {
+  const backendPid = targetConfig?.spawnedAgentPid;
+  const localEntry = ctx.deps.machine.listAgentEntries(ctx.machineId).find((e) => e.chatroomId === chatroomId && e.role.toLowerCase() === role.toLowerCase());
+  const localPid = localEntry?.entry.pid;
+  const allPids = [...new Set([backendPid, localPid].filter((p) => p !== undefined))];
+  if (allPids.length === 0) {
     const msg = "No running agent found (no PID recorded)";
     console.log(`   ⚠️  ${msg}`);
     return { result: msg, failed: true };
   }
-  const pidToKill = targetConfig.spawnedAgentPid;
-  console.log(`   Stopping agent with PID: ${pidToKill}`);
   const anyService = ctx.agentServices.values().next().value;
-  const isAlive = anyService ? anyService.isAlive(pidToKill) : false;
-  if (!isAlive) {
-    console.log(`   ⚠️  PID ${pidToKill} does not appear to belong to the expected agent`);
-    await clearAgentPidEverywhere(ctx, chatroomId, role);
-    console.log(`   Cleared stale PID`);
+  let anyKilled = false;
+  let lastError = null;
+  for (const pid of allPids) {
+    console.log(`   Stopping agent with PID: ${pid}`);
+    const isAlive = anyService ? anyService.isAlive(pid) : false;
+    if (!isAlive) {
+      console.log(`   ⚠️  PID ${pid} not found — process already exited or was never started`);
+      await clearAgentPidEverywhere(ctx, chatroomId, role);
+      console.log(`   Cleared stale PID`);
+      try {
+        await ctx.deps.backend.mutation(api.participants.leave, {
+          sessionId: ctx.sessionId,
+          chatroomId,
+          role
+        });
+        console.log(`   Removed participant record`);
+      } catch {}
+      continue;
+    }
     try {
-      await ctx.deps.backend.mutation(api.participants.leave, {
-        sessionId: ctx.sessionId,
+      const shutdownResult = await onAgentShutdown(ctx, {
         chatroomId,
-        role
+        role,
+        pid
       });
-      console.log(`   Removed participant record`);
-    } catch {}
-    return {
-      result: `PID ${pidToKill} appears stale (process not found or belongs to different program)`,
-      failed: true
-    };
+      const msg = shutdownResult.killed ? `Agent stopped (PID: ${pid})` : `Agent stop attempted (PID: ${pid}) — process may still be running`;
+      console.log(`   ${shutdownResult.killed ? "✅" : "⚠️ "} ${msg}`);
+      if (shutdownResult.killed) {
+        anyKilled = true;
+      }
+    } catch (e) {
+      lastError = e;
+      console.log(`   ⚠️  Failed to stop agent (PID: ${pid}): ${e.message}`);
+    }
   }
-  try {
-    const shutdownResult = await onAgentShutdown(ctx, {
-      chatroomId,
-      role,
-      pid: pidToKill
-    });
-    const msg = shutdownResult.killed ? `Agent stopped (PID: ${pidToKill})` : `Agent stop attempted (PID: ${pidToKill}) — process may still be running`;
-    console.log(`   ${shutdownResult.killed ? "✅" : "⚠️ "} ${msg}`);
-    return { result: msg, failed: !shutdownResult.killed };
-  } catch (e) {
-    const msg = `Failed to stop agent: ${e.message}`;
+  if (lastError && !anyKilled) {
+    const msg = `Failed to stop agent: ${lastError.message}`;
     console.log(`   ⚠️  ${msg}`);
     return { result: msg, failed: true };
   }
+  if (!anyKilled) {
+    return {
+      result: `All recorded PIDs appear stale (processes not found or belong to different programs)`,
+      failed: true
+    };
+  }
+  const killedCount = allPids.length > 1 ? ` (${allPids.length} PIDs)` : ``;
+  return { result: `Agent stopped${killedCount}`, failed: false };
 }
 var init_stop_agent = __esm(() => {
   init_api3();
-  init_on_agent_shutdown();
   init_shared();
 });
 
+// src/events/daemon/agent/on-request-stop-agent.ts
+async function onRequestStopAgent(ctx, event) {
+  if (Date.now() > event.deadline) {
+    console.log(`[daemon] ⏰ Skipping expired agent.requestStop for role=${event.role} (deadline passed)`);
+    return;
+  }
+  await executeStopAgent(ctx, {
+    chatroomId: event.chatroomId,
+    role: event.role,
+    reason: event.reason
+  });
+}
+var init_on_request_stop_agent = __esm(() => {
+  init_stop_agent();
+});
+
+// src/commands/machine/pid.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+function getUrlHash() {
+  const url = getConvexUrl();
+  return createHash("sha256").update(url).digest("hex").substring(0, 8);
+}
+function getPidFileName() {
+  return `daemon-${getUrlHash()}.pid`;
+}
+function ensureChatroomDir() {
+  if (!existsSync4(CHATROOM_DIR4)) {
+    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
+  }
+}
+function getPidFilePath() {
+  return join5(CHATROOM_DIR4, getPidFileName());
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readPid() {
+  const pidPath = getPidFilePath();
+  if (!existsSync4(pidPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync6(pidPath, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    if (isNaN(pid) || pid <= 0) {
+      return null;
+    }
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function writePid() {
+  ensureChatroomDir();
+  const pidPath = getPidFilePath();
+  writeFileSync4(pidPath, process.pid.toString(), "utf-8");
+}
+function removePid() {
+  const pidPath = getPidFilePath();
+  try {
+    if (existsSync4(pidPath)) {
+      unlinkSync2(pidPath);
+    }
+  } catch {}
+}
+function isDaemonRunning() {
+  const pid = readPid();
+  if (pid === null) {
+    return { running: false, pid: null };
+  }
+  if (isProcessRunning(pid)) {
+    return { running: true, pid };
+  }
+  removePid();
+  return { running: false, pid: null };
+}
+function acquireLock() {
+  const { running, pid } = isDaemonRunning();
+  if (running) {
+    console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
+    return false;
+  }
+  writePid();
+  return true;
+}
+function releaseLock() {
+  removePid();
+}
+var CHATROOM_DIR4;
+var init_pid = __esm(() => {
+  init_client2();
+  CHATROOM_DIR4 = join5(homedir4(), ".chatroom");
+});
+
+// src/commands/machine/daemon-start/handlers/ping.ts
+function handlePing() {
+  console.log(`   ↪ Responding: pong`);
+  return { result: "pong", failed: false };
+}
+
 // src/commands/machine/daemon-start/command-loop.ts
 async function refreshModels(ctx) {
   const models = {};
@@ -14204,70 +14182,6 @@ async function refreshModels(ctx) {
     console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
   }
 }
-async function processCommand(ctx, command) {
-  console.log(`[${formatTimestamp()}] \uD83D\uDCE8 Command received: ${command.type}`);
-  try {
-    await ctx.deps.backend.mutation(api.machines.ackCommand, {
-      sessionId: ctx.sessionId,
-      commandId: command._id,
-      status: "processing"
-    });
-    ctx.events.emit("command:processing", {
-      commandId: command._id.toString(),
-      type: command.type
-    });
-    let commandResult;
-    switch (command.type) {
-      case "ping":
-        commandResult = handlePing();
-        break;
-      case "status":
-        commandResult = handleStatus(ctx);
-        break;
-      case "start-agent":
-        commandResult = await handleStartAgent(ctx, command);
-        break;
-      case "stop-agent":
-        commandResult = await handleStopAgent(ctx, command);
-        break;
-      default: {
-        const _exhaustive = command;
-        commandResult = {
-          result: `Unknown command type: ${_exhaustive.type}`,
-          failed: true
-        };
-      }
-    }
-    const finalStatus = commandResult.failed ? "failed" : "completed";
-    await ctx.deps.backend.mutation(api.machines.ackCommand, {
-      sessionId: ctx.sessionId,
-      commandId: command._id,
-      status: finalStatus,
-      result: commandResult.result
-    });
-    ctx.events.emit("command:completed", {
-      commandId: command._id.toString(),
-      type: command.type,
-      failed: commandResult.failed,
-      result: commandResult.result
-    });
-    if (commandResult.failed) {
-      console.log(`   ❌ Command failed: ${commandResult.result}`);
-    } else {
-      console.log(`   ✅ Command completed`);
-    }
-  } catch (error) {
-    console.error(`   ❌ Command failed: ${error.message}`);
-    try {
-      await ctx.deps.backend.mutation(api.machines.ackCommand, {
-        sessionId: ctx.sessionId,
-        commandId: command._id,
-        status: "failed",
-        result: error.message
-      });
-    } catch {}
-  }
-}
 async function startCommandLoop(ctx) {
   let heartbeatCount = 0;
   const heartbeatTimer = setInterval(() => {
@@ -14294,66 +14208,56 @@ async function startCommandLoop(ctx) {
   process.on("SIGTERM", shutdown);
   process.on("SIGHUP", shutdown);
   const wsClient2 = await getConvexWsClient();
-  const commandQueue = [];
-  const queuedCommandIds = new Set;
-  let drainingQueue = false;
-  const enqueueCommands = (commands) => {
-    for (const command of commands) {
-      const commandId = command._id.toString();
-      if (queuedCommandIds.has(commandId))
-        continue;
-      queuedCommandIds.add(commandId);
-      commandQueue.push(command);
-    }
-  };
-  const drainQueue = async () => {
-    if (drainingQueue)
-      return;
-    drainingQueue = true;
-    try {
-      while (commandQueue.length > 0) {
-        const command = commandQueue.shift();
-        const commandId = command._id.toString();
-        queuedCommandIds.delete(commandId);
-        try {
-          await processCommand(ctx, command);
-        } catch (error) {
-          console.error(`   ❌ Command processing failed: ${error.message}`);
-        }
-      }
-    } finally {
-      drainingQueue = false;
-    }
-  };
   console.log(`
 Listening for commands...`);
   console.log(`Press Ctrl+C to stop
 `);
-  wsClient2.onUpdate(api.machines.getPendingCommands, {
+  const processedCommandIds = new Map;
+  const processedPingIds = new Map;
+  wsClient2.onUpdate(api.machines.getCommandEvents, {
     sessionId: ctx.sessionId,
     machineId: ctx.machineId
   }, async (result) => {
-    if (!result.commands || result.commands.length === 0)
+    if (!result.events || result.events.length === 0)
       return;
-    const parsed = [];
-    for (const raw of result.commands) {
-      const command = parseMachineCommand(raw);
-      if (command !== null) {
-        parsed.push(command);
-      } else {
-        try {
-          await ctx.deps.backend.mutation(api.machines.ackCommand, {
+    const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
+    for (const [id, ts] of processedCommandIds) {
+      if (ts < evictBefore)
+        processedCommandIds.delete(id);
+    }
+    for (const [id, ts] of processedPingIds) {
+      if (ts < evictBefore)
+        processedPingIds.delete(id);
+    }
+    for (const event of result.events) {
+      const eventId = event._id.toString();
+      try {
+        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
+        if (event.type === "agent.requestStart") {
+          if (processedCommandIds.has(eventId))
+            continue;
+          processedCommandIds.set(eventId, Date.now());
+          await onRequestStartAgent(ctx, event);
+        } else if (event.type === "agent.requestStop") {
+          if (processedCommandIds.has(eventId))
+            continue;
+          processedCommandIds.set(eventId, Date.now());
+          await onRequestStopAgent(ctx, event);
+        } else if (event.type === "daemon.ping") {
+          if (processedPingIds.has(eventId))
+            continue;
+          processedPingIds.set(eventId, Date.now());
+          handlePing();
+          await ctx.deps.backend.mutation(api.machines.ackPing, {
             sessionId: ctx.sessionId,
-            commandId: raw._id,
-            status: "failed",
-            result: `Invalid command: type="${raw.type}" missing required payload fields`
+            machineId: ctx.machineId,
+            pingEventId: event._id
           });
-          console.warn(`[${formatTimestamp()}] ⚠️  Acked invalid command ${raw._id} (type=${raw.type}) as failed`);
-        } catch {}
+        }
+      } catch (err) {
+        console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
       }
     }
-    enqueueCommands(parsed);
-    await drainQueue();
   });
   const modelRefreshTimer = setInterval(() => {
     refreshModels(ctx).catch((err) => {
@@ -14368,9 +14272,9 @@ var init_command_loop = __esm(() => {
   init_api3();
   init_client2();
   init_on_daemon_shutdown();
+  init_on_request_start_agent();
+  init_on_request_stop_agent();
   init_pid();
-  init_start_agent();
-  init_stop_agent();
   MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 });
 
@@ -14402,7 +14306,7 @@ var init_state_recovery = __esm(() => {
   init_shared();
 });
 
-// src/commands/machine/daemon-start/event-bus.ts
+// src/events/daemon/event-bus.ts
 class DaemonEventBus {
   listeners = new Map;
   on(event, listener) {
@@ -14431,54 +14335,66 @@ class DaemonEventBus {
   }
 }
 
-// src/commands/machine/daemon-start/event-listeners.ts
+// src/events/daemon/agent/on-agent-exited.ts
+function onAgentExited(ctx, payload) {
+  const { chatroomId, role, pid, code: code2, signal, intentional } = payload;
+  const ts = formatTimestamp();
+  if (intentional) {
+    console.log(`[${ts}] ℹ️  Agent process exited after intentional stop ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
+  } else {
+    console.log(`[${ts}] ⚠️  Agent process exited ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
+  }
+  ctx.deps.backend.mutation(api.machines.recordAgentExited, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    chatroomId,
+    role,
+    pid,
+    intentional,
+    exitCode: code2 ?? undefined,
+    signal: signal ?? undefined
+  }).catch((err) => {
+    console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
+  });
+  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
+  for (const service of ctx.agentServices.values()) {
+    service.untrack(pid);
+  }
+}
+var init_on_agent_exited = __esm(() => {
+  init_api3();
+});
+
+// src/events/daemon/agent/on-agent-started.ts
+function onAgentStarted(ctx, payload) {
+  const ts = formatTimestamp();
+  console.log(`[${ts}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
+}
+var init_on_agent_started = () => {};
+
+// src/events/daemon/agent/on-agent-stopped.ts
+function onAgentStopped(ctx, payload) {
+  const ts = formatTimestamp();
+  console.log(`[${ts}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
+}
+var init_on_agent_stopped = () => {};
+
+// src/events/daemon/register-listeners.ts
 function registerEventListeners(ctx) {
   const unsubs = [];
-  unsubs.push(ctx.events.on("agent:exited", (payload) => {
-    const { chatroomId, role, pid, code: code2, signal, intentional } = payload;
-    const ts = formatTimestamp();
-    if (intentional) {
-      console.log(`[${ts}] ℹ️  Agent process exited after intentional stop ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
-    } else {
-      console.log(`[${ts}] ⚠️  Agent process exited ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
-    }
-    ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      chatroomId,
-      role,
-      pid: undefined
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to clear PID in backend: ${err.message}`);
-    });
-    ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
-    for (const service of ctx.agentServices.values()) {
-      service.untrack(pid);
-    }
-    ctx.deps.backend.mutation(api.participants.leave, {
-      sessionId: ctx.sessionId,
-      chatroomId,
-      role
-    }).catch((err) => {
-      console.log(`   ⚠️  Could not remove participant: ${err.message}`);
-    });
-  }));
-  unsubs.push(ctx.events.on("agent:started", (payload) => {
-    const ts = formatTimestamp();
-    console.log(`[${ts}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
-  }));
-  unsubs.push(ctx.events.on("agent:stopped", (payload) => {
-    const ts = formatTimestamp();
-    console.log(`[${ts}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
-  }));
+  unsubs.push(ctx.events.on("agent:exited", (payload) => onAgentExited(ctx, payload)));
+  unsubs.push(ctx.events.on("agent:started", (payload) => onAgentStarted(ctx, payload)));
+  unsubs.push(ctx.events.on("agent:stopped", (payload) => onAgentStopped(ctx, payload)));
   return () => {
     for (const unsub of unsubs) {
       unsub();
     }
   };
 }
-var init_event_listeners = __esm(() => {
-  init_api3();
+var init_register_listeners = __esm(() => {
+  init_on_agent_exited();
+  init_on_agent_started();
+  init_on_agent_stopped();
 });
 
 // src/commands/machine/daemon-start/init.ts
@@ -14520,7 +14436,9 @@ function createDefaultDeps16() {
     machine: {
       clearAgentPid,
       persistAgentPid,
-      listAgentEntries
+      listAgentEntries,
+      persistEventCursor,
+      loadEventCursor
     },
     clock: {
       now: () => Date.now(),
@@ -14649,7 +14567,7 @@ var init_init2 = __esm(() => {
   init_error_formatting();
   init_version();
   init_pid();
-  init_event_listeners();
+  init_register_listeners();
 });
 
 // src/commands/machine/daemon-start/index.ts

package/package.json

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