chatroom-cli 1.4.4 → 1.6.1

package/dist/index.js

@@ -10123,306 +10123,11 @@ var init_auth_logout = __esm(() => {
   init_storage();
 });
 
-// src/infrastructure/machine/types.ts
-var AGENT_HARNESSES, AGENT_HARNESS_COMMANDS, MACHINE_CONFIG_VERSION = "1";
-var init_types = __esm(() => {
-  AGENT_HARNESSES = ["opencode", "pi"];
-  AGENT_HARNESS_COMMANDS = {
-    opencode: "opencode",
-    pi: "pi"
-  };
-});
-
-// src/infrastructure/machine/detection.ts
-import { execSync } from "node:child_process";
-function commandExists(command) {
-  try {
-    const checkCommand = process.platform === "win32" ? `where ${command}` : `which ${command}`;
-    execSync(checkCommand, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parseVersion(versionStr) {
-  const match = versionStr.match(/v?(\d+)\.(\d+)\.(\d+)/);
-  if (!match)
-    return null;
-  const major = parseInt(match[1], 10);
-  const version2 = `${match[1]}.${match[2]}.${match[3]}`;
-  return { version: version2, major };
-}
-function detectHarnessVersion(harness) {
-  const versionCommand = HARNESS_VERSION_COMMANDS[harness];
-  if (!versionCommand)
-    return null;
-  try {
-    const output = execSync(versionCommand, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000
-    }).toString().trim();
-    return parseVersion(output);
-  } catch {
-    return null;
-  }
-}
-function detectHarnessVersions(harnesses) {
-  const versions = {};
-  for (const harness of harnesses) {
-    const version2 = detectHarnessVersion(harness);
-    if (version2) {
-      versions[harness] = version2;
-    }
-  }
-  return versions;
-}
-function detectAvailableHarnesses() {
-  const available = [];
-  for (const harness of AGENT_HARNESSES) {
-    const command = AGENT_HARNESS_COMMANDS[harness];
-    if (commandExists(command)) {
-      available.push(harness);
-    }
-  }
-  return available;
-}
-var HARNESS_VERSION_COMMANDS;
-var init_detection = __esm(() => {
-  init_types();
-  HARNESS_VERSION_COMMANDS = {
-    opencode: "opencode --version",
-    pi: "pi --version"
-  };
-});
-
-// src/infrastructure/machine/storage.ts
-import { randomUUID } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "node:fs";
-import { homedir as homedir2, hostname as hostname2 } from "node:os";
-import { join as join3 } from "node:path";
-function ensureConfigDir2() {
-  if (!existsSync2(CHATROOM_DIR2)) {
-    mkdirSync2(CHATROOM_DIR2, { recursive: true, mode: 448 });
-  }
-}
-function getMachineConfigPath() {
-  return join3(CHATROOM_DIR2, MACHINE_FILE);
-}
-function loadConfigFile() {
-  const configPath = getMachineConfigPath();
-  if (!existsSync2(configPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync3(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    console.warn(`⚠️  Failed to read machine config at ${configPath}: ${error.message}`);
-    console.warn(`   The machine will re-register with a new identity on next startup.`);
-    console.warn(`   If this is unexpected, check the file for corruption.`);
-    return null;
-  }
-}
-function saveConfigFile(configFile) {
-  ensureConfigDir2();
-  const configPath = getMachineConfigPath();
-  const tempPath = `${configPath}.tmp`;
-  const content = JSON.stringify(configFile, null, 2);
-  writeFileSync2(tempPath, content, { encoding: "utf-8", mode: 384 });
-  renameSync(tempPath, configPath);
-}
-function loadMachineConfig() {
-  const configFile = loadConfigFile();
-  if (!configFile)
-    return null;
-  const convexUrl = getConvexUrl();
-  return configFile.machines[convexUrl] ?? null;
-}
-function saveMachineConfig(config) {
-  const configFile = loadConfigFile() ?? {
-    version: MACHINE_CONFIG_VERSION,
-    machines: {}
-  };
-  const convexUrl = getConvexUrl();
-  configFile.machines[convexUrl] = config;
-  saveConfigFile(configFile);
-}
-function createNewEndpointConfig() {
-  const now = new Date().toISOString();
-  const availableHarnesses = detectAvailableHarnesses();
-  return {
-    machineId: randomUUID(),
-    hostname: hostname2(),
-    os: process.platform,
-    registeredAt: now,
-    lastSyncedAt: now,
-    availableHarnesses,
-    harnessVersions: detectHarnessVersions(availableHarnesses)
-  };
-}
-function ensureMachineRegistered() {
-  let config = loadMachineConfig();
-  if (!config) {
-    config = createNewEndpointConfig();
-    saveMachineConfig(config);
-  } else {
-    const now = new Date().toISOString();
-    config.availableHarnesses = detectAvailableHarnesses();
-    config.harnessVersions = detectHarnessVersions(config.availableHarnesses);
-    config.lastSyncedAt = now;
-    saveMachineConfig(config);
-  }
-  return {
-    machineId: config.machineId,
-    hostname: config.hostname,
-    os: config.os,
-    availableHarnesses: config.availableHarnesses,
-    harnessVersions: config.harnessVersions
-  };
-}
-var CHATROOM_DIR2, MACHINE_FILE = "machine.json";
-var init_storage2 = __esm(() => {
-  init_detection();
-  init_types();
-  init_client2();
-  CHATROOM_DIR2 = join3(homedir2(), ".chatroom");
-});
-
-// src/infrastructure/machine/daemon-state.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
-function agentKey(chatroomId, role) {
-  return `${chatroomId}/${role}`;
-}
-function ensureStateDir() {
-  if (!existsSync3(STATE_DIR)) {
-    mkdirSync3(STATE_DIR, { recursive: true, mode: 448 });
-  }
-}
-function stateFilePath(machineId) {
-  return join4(STATE_DIR, `${machineId}.json`);
-}
-function loadDaemonState(machineId) {
-  const filePath = stateFilePath(machineId);
-  if (!existsSync3(filePath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync4(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function saveDaemonState(state) {
-  ensureStateDir();
-  const filePath = stateFilePath(state.machineId);
-  const tempPath = `${filePath}.tmp`;
-  const content = JSON.stringify(state, null, 2);
-  writeFileSync3(tempPath, content, { encoding: "utf-8", mode: 384 });
-  renameSync2(tempPath, filePath);
-}
-function loadOrCreate(machineId) {
-  return loadDaemonState(machineId) ?? {
-    version: STATE_VERSION,
-    machineId,
-    updatedAt: new Date().toISOString(),
-    agents: {}
-  };
-}
-function persistAgentPid(machineId, chatroomId, role, pid, harness) {
-  const state = loadOrCreate(machineId);
-  state.agents[agentKey(chatroomId, role)] = {
-    pid,
-    harness,
-    startedAt: new Date().toISOString()
-  };
-  state.updatedAt = new Date().toISOString();
-  saveDaemonState(state);
-}
-function clearAgentPid(machineId, chatroomId, role) {
-  const state = loadDaemonState(machineId);
-  if (!state)
-    return;
-  const key = agentKey(chatroomId, role);
-  if (!(key in state.agents))
-    return;
-  delete state.agents[key];
-  state.updatedAt = new Date().toISOString();
-  saveDaemonState(state);
-}
-function listAgentEntries(machineId) {
-  const state = loadDaemonState(machineId);
-  if (!state)
-    return [];
-  const results = [];
-  for (const [key, entry] of Object.entries(state.agents)) {
-    const separatorIndex = key.lastIndexOf("/");
-    if (separatorIndex === -1)
-      continue;
-    const chatroomId = key.substring(0, separatorIndex);
-    const role = key.substring(separatorIndex + 1);
-    results.push({ chatroomId, role, entry });
-  }
-  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");
-  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 = "intentional_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_types();
-  init_storage2();
-  init_daemon_state();
-  init_intentional_stops();
-});
-
 // src/infrastructure/services/remote-agents/base-cli-agent-service.ts
-import { spawn, execSync as execSync2 } from "node:child_process";
+import { spawn, execSync } from "node:child_process";
 function defaultDeps() {
   return {
-    execSync: execSync2,
+    execSync,
     spawn,
     kill: (pid, signal) => process.kill(pid, signal)
   };
@@ -10514,6 +10219,9 @@ var OPENCODE_COMMAND = "opencode", OpenCodeAgentService;
 var init_opencode_agent_service = __esm(() => {
   init_base_cli_agent_service();
   OpenCodeAgentService = class OpenCodeAgentService extends BaseCLIAgentService {
+    id = "opencode";
+    displayName = "OpenCode";
+    command = OPENCODE_COMMAND;
     constructor(deps) {
       super(deps);
     }
@@ -10597,10 +10305,6 @@ ${options.prompt}` : options.prompt;
 });
 
 // src/infrastructure/services/remote-agents/opencode/index.ts
-var exports_opencode = {};
-__export(exports_opencode, {
-  OpenCodeAgentService: () => OpenCodeAgentService
-});
 var init_opencode = __esm(() => {
   init_opencode_agent_service();
 });
@@ -10700,6 +10404,9 @@ var init_pi_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_pi_rpc_reader();
   PiAgentService = class PiAgentService extends BaseCLIAgentService {
+    id = "pi";
+    displayName = "Pi";
+    command = PI_COMMAND;
     constructor(deps) {
       super(deps);
     }
@@ -10886,13 +10593,528 @@ var init_pi_agent_service = __esm(() => {
   };
 });
 
-// src/infrastructure/services/remote-agents/pi/index.ts
-var exports_pi = {};
-__export(exports_pi, {
-  PiAgentService: () => PiAgentService
+// src/infrastructure/services/remote-agents/pi/index.ts
+var init_pi = __esm(() => {
+  init_pi_agent_service();
+});
+
+// src/infrastructure/services/remote-agents/cursor/cursor-stream-reader.ts
+import { createInterface as createInterface2 } from "node:readline";
+
+class CursorStreamReader {
+  textCallbacks = [];
+  agentEndCallbacks = [];
+  toolCallCallbacks = [];
+  toolResultCallbacks = [];
+  anyEventCallbacks = [];
+  constructor(stream) {
+    const rl = createInterface2({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => this._handleLine(line));
+  }
+  onText(cb) {
+    this.textCallbacks.push(cb);
+  }
+  onAgentEnd(cb) {
+    this.agentEndCallbacks.push(cb);
+  }
+  onToolCall(cb) {
+    this.toolCallCallbacks.push(cb);
+  }
+  onToolResult(cb) {
+    this.toolResultCallbacks.push(cb);
+  }
+  onAnyEvent(cb) {
+    this.anyEventCallbacks.push(cb);
+  }
+  _handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    for (const cb of this.anyEventCallbacks)
+      cb();
+    const type = event["type"];
+    const subtype = event["subtype"];
+    if (type === "assistant") {
+      const message = event["message"];
+      const content = message?.["content"] ?? [];
+      for (const block of content) {
+        if (block["type"] === "text" && typeof block["text"] === "string") {
+          for (const cb of this.textCallbacks)
+            cb(block["text"]);
+        }
+      }
+      return;
+    }
+    if (type === "tool_call") {
+      const callId = event["call_id"] ?? "";
+      const toolCall = event["tool_call"];
+      if (subtype === "started") {
+        for (const cb of this.toolCallCallbacks)
+          cb(callId, toolCall);
+      } else if (subtype === "completed") {
+        for (const cb of this.toolResultCallbacks)
+          cb(callId, toolCall);
+      }
+      return;
+    }
+    if (type === "result" && subtype === "success") {
+      const sessionId = event["session_id"];
+      for (const cb of this.agentEndCallbacks)
+        cb(sessionId);
+      return;
+    }
+  }
+}
+var init_cursor_stream_reader = () => {};
+
+// src/infrastructure/services/remote-agents/cursor/cursor-agent-service.ts
+var CURSOR_COMMAND = "agent", CURSOR_MODELS, CursorAgentService;
+var init_cursor_agent_service = __esm(() => {
+  init_base_cli_agent_service();
+  init_cursor_stream_reader();
+  CURSOR_MODELS = ["opus-4.6", "sonnet-4.6"];
+  CursorAgentService = class CursorAgentService extends BaseCLIAgentService {
+    id = "cursor";
+    displayName = "Cursor";
+    command = CURSOR_COMMAND;
+    constructor(deps) {
+      super(deps);
+    }
+    isInstalled() {
+      return this.checkInstalled(CURSOR_COMMAND);
+    }
+    getVersion() {
+      return this.checkVersion(CURSOR_COMMAND);
+    }
+    async listModels() {
+      return CURSOR_MODELS;
+    }
+    async spawn(options) {
+      const args = ["-p", "--force", "--output-format", "stream-json"];
+      if (options.model) {
+        args.push("--model", options.model);
+      }
+      const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
+
+${options.prompt}` : options.prompt;
+      const childProcess = this.deps.spawn(CURSOR_COMMAND, args, {
+        cwd: options.workingDir,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: true,
+        env: { ...process.env }
+      });
+      childProcess.stdin?.write(fullPrompt);
+      childProcess.stdin?.end();
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (childProcess.killed || childProcess.exitCode !== null) {
+        throw new Error(`Agent process exited immediately (exit code: ${childProcess.exitCode})`);
+      }
+      if (!childProcess.pid) {
+        throw new Error("Agent process started but has no PID");
+      }
+      const pid = childProcess.pid;
+      const context = options.context;
+      const entry = this.registerProcess(pid, context);
+      const roleTag = context.role ?? "unknown";
+      const chatroomSuffix = context.chatroomId ? `@${context.chatroomId.slice(-6)}` : "";
+      const logPrefix = `[cursor:${roleTag}${chatroomSuffix}`;
+      const outputCallbacks = [];
+      if (childProcess.stdout) {
+        const reader = new CursorStreamReader(childProcess.stdout);
+        let textBuffer = "";
+        const flushText = () => {
+          if (!textBuffer)
+            return;
+          for (const line of textBuffer.split(`
+`)) {
+            if (line)
+              process.stdout.write(`${logPrefix} text] ${line}
+`);
+          }
+          textBuffer = "";
+        };
+        reader.onText((text) => {
+          textBuffer += text;
+          if (textBuffer.includes(`
+`))
+            flushText();
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+        reader.onAnyEvent(() => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+        reader.onAgentEnd(() => {
+          flushText();
+          process.stdout.write(`${logPrefix} agent_end]
+`);
+        });
+        reader.onToolCall((callId, toolCall) => {
+          flushText();
+          process.stdout.write(`${logPrefix} tool: ${callId} ${JSON.stringify(toolCall)}]
+`);
+        });
+        reader.onToolResult((callId) => {
+          flushText();
+          process.stdout.write(`${logPrefix} tool_result: ${callId}]
+`);
+        });
+        if (childProcess.stderr) {
+          childProcess.stderr.pipe(process.stderr, { end: false });
+          childProcess.stderr.on("data", () => {
+            entry.lastOutputAt = Date.now();
+            for (const cb of outputCallbacks)
+              cb();
+          });
+        }
+        return {
+          pid,
+          onExit: (cb) => {
+            childProcess.on("exit", (code2, signal) => {
+              this.deleteProcess(pid);
+              cb({ code: code2, signal, context });
+            });
+          },
+          onOutput: (cb) => {
+            outputCallbacks.push(cb);
+          },
+          onAgentEnd: (cb) => {
+            reader.onAgentEnd(cb);
+          }
+        };
+      }
+      if (childProcess.stderr) {
+        childProcess.stderr.pipe(process.stderr, { end: false });
+        childProcess.stderr.on("data", () => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+      }
+      return {
+        pid,
+        onExit: (cb) => {
+          childProcess.on("exit", (code2, signal) => {
+            this.deleteProcess(pid);
+            cb({ code: code2, signal, context });
+          });
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        }
+      };
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/cursor/index.ts
+var init_cursor = __esm(() => {
+  init_cursor_agent_service();
+});
+
+// src/infrastructure/services/remote-agents/registry.ts
+function registerHarness(service) {
+  registry.set(service.id, service);
+}
+function getHarness(id) {
+  return registry.get(id);
+}
+function getAllHarnesses() {
+  return [...registry.values()];
+}
+var registry;
+var init_registry = __esm(() => {
+  registry = new Map;
+});
+
+// src/infrastructure/services/remote-agents/init-registry.ts
+function initHarnessRegistry() {
+  if (initialized)
+    return;
+  registerHarness(new OpenCodeAgentService);
+  registerHarness(new PiAgentService);
+  registerHarness(new CursorAgentService);
+  initialized = true;
+}
+var initialized = false;
+var init_init_registry = __esm(() => {
+  init_registry();
+  init_opencode();
+  init_pi();
+  init_cursor();
+});
+
+// src/infrastructure/services/remote-agents/index.ts
+var init_remote_agents = __esm(() => {
+  init_opencode();
+  init_pi();
+  init_cursor();
+  init_registry();
+  init_init_registry();
+});
+
+// src/infrastructure/machine/detection.ts
+function detectHarnessVersion(harness) {
+  initHarnessRegistry();
+  const info = getHarness(harness)?.getVersion();
+  if (!info)
+    return null;
+  return { version: info.version, major: info.major };
+}
+function detectHarnessVersions(harnesses) {
+  const versions = {};
+  for (const harness of harnesses) {
+    const version2 = detectHarnessVersion(harness);
+    if (version2) {
+      versions[harness] = version2;
+    }
+  }
+  return versions;
+}
+function detectAvailableHarnesses() {
+  initHarnessRegistry();
+  return getAllHarnesses().filter((s) => s.isInstalled()).map((s) => s.id);
+}
+var init_detection = __esm(() => {
+  init_remote_agents();
+});
+
+// src/infrastructure/machine/types.ts
+var MACHINE_CONFIG_VERSION = "1";
+
+// src/infrastructure/machine/storage.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "node:fs";
+import { homedir as homedir2, hostname as hostname2 } from "node:os";
+import { join as join3 } from "node:path";
+function ensureConfigDir2() {
+  if (!existsSync2(CHATROOM_DIR2)) {
+    mkdirSync2(CHATROOM_DIR2, { recursive: true, mode: 448 });
+  }
+}
+function getMachineConfigPath() {
+  return join3(CHATROOM_DIR2, MACHINE_FILE);
+}
+function loadConfigFile() {
+  const configPath = getMachineConfigPath();
+  if (!existsSync2(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`⚠️  Failed to read machine config at ${configPath}: ${error.message}`);
+    console.warn(`   The machine will re-register with a new identity on next startup.`);
+    console.warn(`   If this is unexpected, check the file for corruption.`);
+    return null;
+  }
+}
+function saveConfigFile(configFile) {
+  ensureConfigDir2();
+  const configPath = getMachineConfigPath();
+  const tempPath = `${configPath}.tmp`;
+  const content = JSON.stringify(configFile, null, 2);
+  writeFileSync2(tempPath, content, { encoding: "utf-8", mode: 384 });
+  renameSync(tempPath, configPath);
+}
+function loadMachineConfig() {
+  const configFile = loadConfigFile();
+  if (!configFile)
+    return null;
+  const convexUrl = getConvexUrl();
+  return configFile.machines[convexUrl] ?? null;
+}
+function saveMachineConfig(config) {
+  const configFile = loadConfigFile() ?? {
+    version: MACHINE_CONFIG_VERSION,
+    machines: {}
+  };
+  const convexUrl = getConvexUrl();
+  configFile.machines[convexUrl] = config;
+  saveConfigFile(configFile);
+}
+function createNewEndpointConfig() {
+  const now = new Date().toISOString();
+  const availableHarnesses = detectAvailableHarnesses();
+  return {
+    machineId: randomUUID(),
+    hostname: hostname2(),
+    os: process.platform,
+    registeredAt: now,
+    lastSyncedAt: now,
+    availableHarnesses,
+    harnessVersions: detectHarnessVersions(availableHarnesses)
+  };
+}
+function ensureMachineRegistered() {
+  let config = loadMachineConfig();
+  if (!config) {
+    config = createNewEndpointConfig();
+    saveMachineConfig(config);
+  } else {
+    const now = new Date().toISOString();
+    config.availableHarnesses = detectAvailableHarnesses();
+    config.harnessVersions = detectHarnessVersions(config.availableHarnesses);
+    config.lastSyncedAt = now;
+    saveMachineConfig(config);
+  }
+  return {
+    machineId: config.machineId,
+    hostname: config.hostname,
+    os: config.os,
+    availableHarnesses: config.availableHarnesses,
+    harnessVersions: config.harnessVersions
+  };
+}
+function getMachineId() {
+  const config = loadMachineConfig();
+  return config?.machineId ?? null;
+}
+var CHATROOM_DIR2, MACHINE_FILE = "machine.json";
+var init_storage2 = __esm(() => {
+  init_detection();
+  init_client2();
+  CHATROOM_DIR2 = join3(homedir2(), ".chatroom");
+});
+
+// src/infrastructure/machine/daemon-state.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+function agentKey(chatroomId, role) {
+  return `${chatroomId}/${role}`;
+}
+function ensureStateDir() {
+  if (!existsSync3(STATE_DIR)) {
+    mkdirSync3(STATE_DIR, { recursive: true, mode: 448 });
+  }
+}
+function stateFilePath(machineId) {
+  return join4(STATE_DIR, `${machineId}.json`);
+}
+function loadDaemonState(machineId) {
+  const filePath = stateFilePath(machineId);
+  if (!existsSync3(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveDaemonState(state) {
+  ensureStateDir();
+  const filePath = stateFilePath(state.machineId);
+  const tempPath = `${filePath}.tmp`;
+  const content = JSON.stringify(state, null, 2);
+  writeFileSync3(tempPath, content, { encoding: "utf-8", mode: 384 });
+  renameSync2(tempPath, filePath);
+}
+function loadOrCreate(machineId) {
+  return loadDaemonState(machineId) ?? {
+    version: STATE_VERSION,
+    machineId,
+    updatedAt: new Date().toISOString(),
+    agents: {}
+  };
+}
+function persistAgentPid(machineId, chatroomId, role, pid, harness) {
+  const state = loadOrCreate(machineId);
+  state.agents[agentKey(chatroomId, role)] = {
+    pid,
+    harness,
+    startedAt: new Date().toISOString()
+  };
+  state.updatedAt = new Date().toISOString();
+  saveDaemonState(state);
+}
+function clearAgentPid(machineId, chatroomId, role) {
+  const state = loadDaemonState(machineId);
+  if (!state)
+    return;
+  const key = agentKey(chatroomId, role);
+  if (!(key in state.agents))
+    return;
+  delete state.agents[key];
+  state.updatedAt = new Date().toISOString();
+  saveDaemonState(state);
+}
+function listAgentEntries(machineId) {
+  const state = loadDaemonState(machineId);
+  if (!state)
+    return [];
+  const results = [];
+  for (const [key, entry] of Object.entries(state.agents)) {
+    const separatorIndex = key.lastIndexOf("/");
+    if (separatorIndex === -1)
+      continue;
+    const chatroomId = key.substring(0, separatorIndex);
+    const role = key.substring(separatorIndex + 1);
+    results.push({ chatroomId, role, entry });
+  }
+  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");
+  STATE_DIR = join4(CHATROOM_DIR3, "machines", "state");
 });
-var init_pi = __esm(() => {
-  init_pi_agent_service();
+
+// 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
@@ -10900,29 +11122,10 @@ var exports_auth_status = {};
 __export(exports_auth_status, {
   authStatus: () => authStatus
 });
-async function listAvailableModelsDefault() {
-  const results = {};
-  try {
-    const { OpenCodeAgentService: OpenCodeAgentService2 } = await Promise.resolve().then(() => (init_opencode(), exports_opencode));
-    const agentService = new OpenCodeAgentService2;
-    if (agentService.isInstalled()) {
-      results["opencode"] = await agentService.listModels();
-    }
-  } catch {}
-  try {
-    const { PiAgentService: PiAgentService2 } = await Promise.resolve().then(() => (init_pi(), exports_pi));
-    const piService = new PiAgentService2;
-    if (piService.isInstalled()) {
-      results["pi"] = await piService.listModels();
-    }
-  } catch {}
-  return results;
-}
 async function createDefaultDeps3() {
   const client2 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
       query: (endpoint, args) => client2.query(endpoint, args)
     },
     session: {
@@ -10931,8 +11134,7 @@ async function createDefaultDeps3() {
       isAuthenticated
     },
     getVersion,
-    ensureMachineRegistered,
-    listAvailableModels: listAvailableModelsDefault
+    loadMachineConfig
   };
 }
 async function authStatus(deps) {
@@ -10968,32 +11170,18 @@ ${"═".repeat(50)}`);
       if (validation.userName) {
         console.log(`\uD83D\uDC64 User: ${validation.userName}`);
       }
-      try {
-        const machineInfo = d.ensureMachineRegistered();
-        const availableModels = await d.listAvailableModels();
-        await d.backend.mutation(api.machines.register, {
-          sessionId: authData.sessionId,
-          machineId: machineInfo.machineId,
-          hostname: machineInfo.hostname,
-          os: machineInfo.os,
-          availableHarnesses: machineInfo.availableHarnesses,
-          harnessVersions: machineInfo.harnessVersions,
-          availableModels
-        });
+      const machineConfig = d.loadMachineConfig();
+      if (machineConfig) {
         console.log(`
-\uD83D\uDDA5️  Machine registered: ${machineInfo.hostname}`);
-        console.log(`   ID: ${machineInfo.machineId}`);
-        if (machineInfo.availableHarnesses.length > 0) {
-          console.log(`   Harnesses: ${machineInfo.availableHarnesses.join(", ")}`);
+\uD83D\uDDA5️  Machine: ${machineConfig.hostname}`);
+        console.log(`   ID: ${machineConfig.machineId}`);
+        if (machineConfig.availableHarnesses.length > 0) {
+          console.log(`   Harnesses: ${machineConfig.availableHarnesses.join(", ")}`);
         }
-        const totalModels = Object.values(availableModels).flat().length;
-        if (totalModels > 0) {
-          console.log(`   Models: ${totalModels} discovered`);
-        }
-      } catch (machineError) {
-        const err = machineError;
+      } else {
         console.log(`
-⚠️  Machine registration skipped: ${err.message}`);
+\uD83D\uDDA5️  Machine: not registered`);
+        console.log(`   Run \`chatroom machine start\` to register this machine.`);
       }
     } else {
       console.log(`
@@ -11315,46 +11503,24 @@ async function registerAgent(chatroomId, options, deps) {
     process.exit(1);
   }
   if (type === "remote") {
+    const machineId = getMachineId();
+    if (!machineId) {
+      console.error(`❌ Machine not registered. Run \`chatroom machine start\` first.`);
+      process.exit(1);
+    }
+    const config = loadMachineConfig();
     try {
-      const machineInfo = ensureMachineRegistered();
-      const availableModels = {};
-      try {
-        const opencodeService = new OpenCodeAgentService;
-        if (opencodeService.isInstalled()) {
-          availableModels["opencode"] = await opencodeService.listModels();
-        }
-      } catch {}
-      try {
-        const piService = new PiAgentService;
-        if (piService.isInstalled()) {
-          availableModels["pi"] = await piService.listModels();
-        }
-      } catch {}
-      await d.backend.mutation(api.machines.register, {
+      await d.backend.mutation(api.machines.recordAgentRegistered, {
         sessionId,
-        machineId: machineInfo.machineId,
-        hostname: machineInfo.hostname,
-        os: machineInfo.os,
-        availableHarnesses: machineInfo.availableHarnesses,
-        harnessVersions: machineInfo.harnessVersions,
-        availableModels
+        chatroomId,
+        role,
+        agentType: "remote",
+        machineId
       });
-      try {
-        await d.backend.mutation(api.machines.recordAgentRegistered, {
-          sessionId,
-          chatroomId,
-          role,
-          agentType: "remote",
-          machineId: machineInfo.machineId
-        });
-      } catch {}
-      console.log(`✅ Registered as remote agent for role "${role}"`);
-      console.log(`   Machine: ${machineInfo.hostname} (${machineInfo.machineId})`);
-      console.log(`   Working directory: ${process.cwd()}`);
-    } catch (error) {
-      console.error(`❌ Registration failed: ${error.message}`);
-      process.exit(1);
-    }
+    } catch {}
+    console.log(`✅ Registered as remote agent for role "${role}"`);
+    console.log(`   Machine: ${config?.hostname ?? "unknown"} (${machineId})`);
+    console.log(`   Working directory: ${process.cwd()}`);
   } else {
     try {
       await d.backend.mutation(api.machines.saveTeamAgentConfig, {
@@ -11375,8 +11541,6 @@ var init_register_agent = __esm(() => {
   init_storage();
   init_client2();
   init_machine();
-  init_opencode();
-  init_pi();
 });
 // ../../services/backend/prompts/cli/task-started/command.ts
 function taskStartedCommand(params) {
@@ -11737,7 +11901,6 @@ var init_session = __esm(() => {
 var exports_get_next_task = {};
 __export(exports_get_next_task, {
   getNextTask: () => getNextTask,
-  WaitForTaskSession: () => GetNextTaskSession,
   GetNextTaskSession: () => GetNextTaskSession
 });
 async function getNextTask(chatroomId, options) {
@@ -11789,35 +11952,6 @@ async function getNextTask(chatroomId, options) {
     console.error(`❌ Chatroom ${chatroomId} not found or access denied`);
     process.exit(1);
   }
-  try {
-    const machineInfo = ensureMachineRegistered();
-    const availableModels = {};
-    try {
-      const opencodeService = new OpenCodeAgentService;
-      if (opencodeService.isInstalled()) {
-        availableModels["opencode"] = await opencodeService.listModels();
-      }
-    } catch {}
-    try {
-      const piService = new PiAgentService;
-      if (piService.isInstalled()) {
-        availableModels["pi"] = await piService.listModels();
-      }
-    } catch {}
-    await client2.mutation(api.machines.register, {
-      sessionId,
-      machineId: machineInfo.machineId,
-      hostname: machineInfo.hostname,
-      os: machineInfo.os,
-      availableHarnesses: machineInfo.availableHarnesses,
-      harnessVersions: machineInfo.harnessVersions,
-      availableModels
-    });
-  } catch (machineError) {
-    if (!silent) {
-      console.warn(`⚠️  Machine registration failed: ${sanitizeUnknownForTerminal(machineError.message)}`);
-    }
-  }
   const connectionId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
   let participantAgentType;
   try {
@@ -11850,6 +11984,8 @@ async function getNextTask(chatroomId, options) {
     if (initPromptResult?.prompt) {
       const connectedTime = new Date().toISOString().replace("T", " ").substring(0, 19);
       console.log(`[${connectedTime}] ✅ Connected. Waiting for task...
+`);
+      console.log(`⚠️ IMPORTANT: This command must stay in the FOREGROUND. If moved to background, terminate and restart it — background processes cannot deliver tasks.
 `);
       if (!initPromptResult.hasSystemPromptControl) {
         console.log("<!-- REFERENCE: Agent Initialization");
@@ -11886,14 +12022,10 @@ var init_get_next_task = __esm(() => {
   init_env();
   init_session();
   init_api3();
-  init_storage();
-  init_client2();
-  init_machine();
-  init_opencode();
-  init_pi();
+  init_storage();
+  init_client2();
   init_error_formatting();
   init_session();
-  init_session();
 });
 
 // src/commands/task-started/index.ts
@@ -12309,7 +12441,15 @@ ${error instanceof Error ? error.message : String(error)}`);
     const cliEnvPrefix2 = getCliEnvPrefix(convexUrl2);
     console.error(`
 ❌ ERROR: ${result.error.message}`);
-    if (result.error.suggestedTarget) {
+    if (result.error.code === "INVALID_TARGET_ROLE" && result.error.suggestedTargets) {
+      console.error(`
+\uD83D\uDCCB Available handoff targets for this team:`);
+      for (const target of result.error.suggestedTargets) {
+        console.error(`   • ${target}`);
+      }
+      console.error(`
+\uD83D\uDCA1 Check your team's workflow in the system prompt for valid handoff paths.`);
+    } else if (result.error.suggestedTarget) {
       console.error(`
 \uD83D\uDCA1 Try this instead:`);
       console.error("```");
@@ -13699,7 +13839,7 @@ function formatTimestamp() {
 async function onAgentShutdown(ctx, options) {
   const { chatroomId, role, pid, skipKill } = options;
   try {
-    ctx.deps.stops.mark(chatroomId, role, options.stopReason ?? "intentional_stop");
+    ctx.deps.stops.mark(chatroomId, role, options.stopReason ?? "user.stop");
   } catch (e) {
     console.log(`   ⚠️  Failed to mark intentional stop for ${role}: ${e.message}`);
   }
@@ -13801,187 +13941,6 @@ var init_on_daemon_shutdown = __esm(() => {
   init_api3();
 });
 
-// src/infrastructure/machine/stop-reason.ts
-function resolveStopReason(code2, signal, wasIntentional) {
-  if (wasIntentional)
-    return "intentional_stop";
-  if (signal !== null)
-    return "process_terminated_with_signal";
-  if (code2 === 0)
-    return "process_exited_with_success";
-  return "process_terminated_unexpectedly";
-}
-
-// src/commands/machine/daemon-start/handlers/start-agent.ts
-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}`);
-  }
-  if (!workingDir) {
-    const msg2 = `No workingDir provided in command payload for ${chatroomId}/${role}`;
-    console.log(`   ⚠️  ${msg2}`);
-    return { result: msg2, failed: true };
-  }
-  console.log(`      Working dir: ${workingDir}`);
-  try {
-    const dirStat = await ctx.deps.fs.stat(workingDir);
-    if (!dirStat.isDirectory()) {
-      const msg2 = `Working directory is not a directory: ${workingDir}`;
-      console.log(`   ⚠️  ${msg2}`);
-      return { result: msg2, failed: true };
-    }
-  } catch {
-    const msg2 = `Working directory does not exist: ${workingDir}`;
-    console.log(`   ⚠️  ${msg2}`);
-    return { result: msg2, failed: true };
-  }
-  try {
-    const existingConfigs = await ctx.deps.backend.query(api.machines.getAgentConfigs, {
-      sessionId: ctx.sessionId,
-      chatroomId
-    });
-    const existingConfig = existingConfigs.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
-    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: ${pid2}) — stopping before respawn`);
-        await onAgentShutdown(ctx, { chatroomId, role, pid: pid2, stopReason: "daemon_respawn_stop" });
-        console.log(`   ✅ Existing agent stopped (PID: ${pid2})`);
-      }
-    }
-  } catch (e) {
-    console.log(`   ⚠️  Could not check for existing agent (proceeding): ${e.message}`);
-  }
-  const convexUrl = getConvexUrl();
-  const initPromptResult = await ctx.deps.backend.query(api.messages.getInitPrompt, {
-    sessionId: ctx.sessionId,
-    chatroomId,
-    role,
-    convexUrl
-  });
-  if (!initPromptResult?.prompt) {
-    const msg2 = "Failed to fetch init prompt from backend";
-    console.log(`   ⚠️  ${msg2}`);
-    return { result: msg2, failed: true };
-  }
-  console.log(`   Fetched split init prompt from backend`);
-  const service = ctx.agentServices.get(agentHarness);
-  if (!service) {
-    const msg2 = `Unknown agent harness: ${agentHarness}`;
-    console.log(`   ⚠️  ${msg2}`);
-    return { result: msg2, failed: true };
-  }
-  let spawnResult;
-  try {
-    spawnResult = await service.spawn({
-      workingDir,
-      prompt: initPromptResult.initialMessage,
-      systemPrompt: initPromptResult.rolePrompt,
-      model,
-      context: { machineId: ctx.machineId, chatroomId, role }
-    });
-  } catch (e) {
-    const msg2 = `Failed to spawn agent: ${e.message}`;
-    console.log(`   ⚠️  ${msg2}`);
-    return { result: msg2, failed: true };
-  }
-  const { pid } = spawnResult;
-  const msg = `Agent spawned (PID: ${pid})`;
-  console.log(`   ✅ ${msg}`);
-  try {
-    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      chatroomId,
-      role,
-      pid,
-      model
-    });
-    console.log(`   Updated backend with PID: ${pid}`);
-    ctx.deps.machine.persistAgentPid(ctx.machineId, chatroomId, role, pid, agentHarness);
-  } catch (e) {
-    console.log(`   ⚠️  Failed to update PID in backend: ${e.message}`);
-  }
-  ctx.events.emit("agent:started", {
-    chatroomId,
-    role,
-    pid,
-    harness: agentHarness,
-    model
-  });
-  spawnResult.onExit(({ code: code2, signal }) => {
-    const pendingReason = ctx.deps.stops.consume(chatroomId, role);
-    const stopReason = pendingReason ?? resolveStopReason(code2, signal, false);
-    ctx.events.emit("agent:exited", {
-      chatroomId,
-      role,
-      pid,
-      code: code2,
-      signal,
-      stopReason,
-      intentional: pendingReason !== null
-    });
-  });
-  if (spawnResult.onAgentEnd) {
-    spawnResult.onAgentEnd(() => {
-      try {
-        ctx.deps.processes.kill(-pid, "SIGTERM");
-      } catch {}
-    });
-  }
-  let lastReportedTokenAt = 0;
-  spawnResult.onOutput(() => {
-    const now = Date.now();
-    if (now - lastReportedTokenAt >= 30000) {
-      lastReportedTokenAt = now;
-      ctx.deps.backend.mutation(api.participants.updateTokenActivity, {
-        sessionId: ctx.sessionId,
-        chatroomId,
-        role
-      }).catch(() => {});
-    }
-  });
-  return { result: msg, failed: false };
-}
-var init_start_agent = __esm(() => {
-  init_api3();
-  init_client2();
-});
-
-// 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
-  });
-}
-var init_on_request_start_agent = __esm(() => {
-  init_start_agent();
-});
-
 // src/commands/machine/daemon-start/handlers/shared.ts
 async function clearAgentPidEverywhere(ctx, chatroomId, role) {
   try {
@@ -13989,107 +13948,44 @@ async function clearAgentPidEverywhere(ctx, chatroomId, role) {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
       chatroomId,
-      role,
-      pid: undefined
-    });
-  } catch (e) {
-    console.log(`   ⚠️  Failed to clear PID in backend: ${e.message}`);
-  }
-  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
-}
-var init_shared = __esm(() => {
-  init_api3();
-});
-
-// src/commands/machine/daemon-start/handlers/stop-agent.ts
-async function executeStopAgent(ctx, args) {
-  const { chatroomId, role } = args;
-  console.log(`   ↪ stop-agent command received`);
-  console.log(`      Chatroom: ${chatroomId}`);
-  console.log(`      Role: ${role}`);
-  const configsResult = await ctx.deps.backend.query(api.machines.getAgentConfigs, {
-    sessionId: ctx.sessionId,
-    chatroomId
-  });
-  const targetConfig = configsResult.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
-  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 anyService = ctx.agentServices.values().next().value;
-  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 {
-      const shutdownResult = await onAgentShutdown(ctx, {
-        chatroomId,
-        role,
-        pid
-      });
-      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}`);
-    }
-  }
-  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
-    };
+      role,
+      pid: undefined
+    });
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear PID in backend: ${e.message}`);
   }
-  const killedCount = allPids.length > 1 ? ` (${allPids.length} PIDs)` : ``;
-  return { result: `Agent stopped${killedCount}`, failed: false };
+  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
 }
-var init_stop_agent = __esm(() => {
+var init_shared = __esm(() => {
   init_api3();
-  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)`);
+// src/commands/machine/daemon-start/handlers/state-recovery.ts
+async function recoverAgentState(ctx) {
+  const entries = ctx.deps.machine.listAgentEntries(ctx.machineId);
+  if (entries.length === 0) {
+    console.log(`   No agent entries found — nothing to recover`);
     return;
   }
-  await executeStopAgent(ctx, {
-    chatroomId: event.chatroomId,
-    role: event.role,
-    reason: event.reason
-  });
+  let recovered = 0;
+  let cleared = 0;
+  for (const { chatroomId, role, entry } of entries) {
+    const { pid, harness } = entry;
+    const service = ctx.agentServices.get(harness) ?? ctx.agentServices.values().next().value;
+    const alive = service ? service.isAlive(pid) : false;
+    if (alive) {
+      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
+      recovered++;
+    } else {
+      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
+      await clearAgentPidEverywhere(ctx, chatroomId, role);
+      cleared++;
+    }
+  }
+  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
 }
-var init_on_request_stop_agent = __esm(() => {
-  init_stop_agent();
+var init_state_recovery = __esm(() => {
+  init_shared();
 });
 
 // src/commands/machine/pid.ts
@@ -14178,459 +14074,693 @@ var init_pid = __esm(() => {
   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/events/daemon/event-bus.ts
+class DaemonEventBus {
+  listeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.listeners.get(event)?.delete(listener);
+    };
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const listener of set) {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.warn(`[EventBus] Listener error on "${event}": ${err.message}`);
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
 }
 
-// src/commands/machine/daemon-start/command-loop.ts
-async function refreshModels(ctx) {
-  const models = {};
-  for (const [harness, service] of ctx.agentServices) {
-    if (!service.isInstalled())
-      continue;
-    try {
-      models[harness] = await service.listModels();
-    } catch {}
+// src/events/daemon/agent/on-agent-exited.ts
+function onAgentExited(ctx, payload) {
+  const { chatroomId, role, pid, code: code2, signal, stopReason, intentional } = payload;
+  const ts = formatTimestamp();
+  console.log(`[${ts}] Agent stopped: ${stopReason} (${role})`);
+  const isDaemonRespawn = stopReason === "daemon.respawn";
+  const isIntentional = intentional && !isDaemonRespawn;
+  if (isIntentional) {
+    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})`);
+  } else {
+    console.log(`[${ts}] ⚠️  Agent process exited ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
   }
-  if (!ctx.config)
-    return;
-  const freshConfig = ensureMachineRegistered();
-  ctx.config.availableHarnesses = freshConfig.availableHarnesses;
-  ctx.config.harnessVersions = freshConfig.harnessVersions;
-  const totalCount = Object.values(models).flat().length;
+  ctx.deps.backend.mutation(api.machines.recordAgentExited, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    chatroomId,
+    role,
+    pid,
+    intentional,
+    stopReason,
+    stopSignal: stopReason === "agent_process.signal" ? signal ?? undefined : undefined,
+    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) => 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_register_listeners = __esm(() => {
+  init_on_agent_exited();
+  init_on_agent_started();
+  init_on_agent_stopped();
+});
+
+// src/commands/machine/daemon-start/init.ts
+import { stat } from "node:fs/promises";
+async function discoverModels(agentServices) {
+  const results = {};
+  for (const [harness, service] of agentServices) {
+    if (service.isInstalled()) {
+      try {
+        results[harness] = await service.listModels();
+      } catch {
+        results[harness] = [];
+      }
+    }
+  }
+  return results;
+}
+function createDefaultDeps16() {
+  return {
+    backend: {
+      mutation: async () => {
+        throw new Error("Backend not initialized");
+      },
+      query: async () => {
+        throw new Error("Backend not initialized");
+      }
+    },
+    processes: {
+      kill: (pid, signal) => process.kill(pid, signal)
+    },
+    fs: {
+      stat
+    },
+    stops: {
+      mark: markIntentionalStop,
+      consume: consumeIntentionalStop,
+      clear: clearIntentionalStop
+    },
+    machine: {
+      clearAgentPid,
+      persistAgentPid,
+      listAgentEntries,
+      persistEventCursor,
+      loadEventCursor
+    },
+    clock: {
+      now: () => Date.now(),
+      delay: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+    }
+  };
+}
+function validateAuthentication(convexUrl) {
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    const otherUrls = getOtherSessionUrls();
+    console.error(`❌ Not authenticated for: ${convexUrl}`);
+    if (otherUrls.length > 0) {
+      console.error(`
+\uD83D\uDCA1 You have sessions for other environments:`);
+      for (const url of otherUrls) {
+        console.error(`   • ${url}`);
+      }
+    }
+    console.error(`
+Run: chatroom auth login`);
+    releaseLock();
+    process.exit(1);
+  }
+  return sessionId;
+}
+async function validateSession(client2, sessionId, convexUrl) {
+  const validation = await client2.query(api.cliAuth.validateSession, { sessionId });
+  if (!validation.valid) {
+    console.error(`❌ Session invalid: ${validation.reason}`);
+    console.error(`
+Run: chatroom auth login`);
+    releaseLock();
+    process.exit(1);
+  }
+}
+function setupMachine() {
+  ensureMachineRegistered();
+  const config3 = loadMachineConfig();
+  return config3;
+}
+async function registerCapabilities(client2, sessionId, config3, agentServices) {
+  const { machineId } = config3;
+  const availableModels = await discoverModels(agentServices);
   try {
-    await ctx.deps.backend.mutation(api.machines.register, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      hostname: ctx.config.hostname,
-      os: ctx.config.os,
-      availableHarnesses: ctx.config.availableHarnesses,
-      harnessVersions: ctx.config.harnessVersions,
-      availableModels: models
+    await client2.mutation(api.machines.register, {
+      sessionId,
+      machineId,
+      hostname: config3.hostname,
+      os: config3.os,
+      availableHarnesses: config3.availableHarnesses,
+      harnessVersions: config3.harnessVersions,
+      availableModels
+    });
+  } catch (error) {
+    console.warn(`⚠️  Machine registration update failed: ${error.message}`);
+  }
+  return availableModels;
+}
+async function connectDaemon(client2, sessionId, machineId, convexUrl) {
+  try {
+    await client2.mutation(api.machines.updateDaemonStatus, {
+      sessionId,
+      machineId,
+      connected: true
     });
-    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh: ${totalCount > 0 ? `${totalCount} models` : "none discovered"}`);
   } catch (error) {
-    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
+    if (isNetworkError(error)) {
+      formatConnectivityError(error, convexUrl);
+    } else {
+      console.error(`❌ Failed to update daemon status: ${error.message}`);
+    }
+    releaseLock();
+    process.exit(1);
   }
 }
-function evictStaleDedupEntries(processedCommandIds, processedPingIds) {
-  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);
-  }
+function logStartup(ctx, availableModels) {
+  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
+  console.log(`   CLI version: ${getVersion()}`);
+  console.log(`   Machine ID: ${ctx.machineId}`);
+  console.log(`   Hostname: ${ctx.config?.hostname ?? "unknown"}`);
+  console.log(`   Available harnesses: ${ctx.config?.availableHarnesses.join(", ") || "none"}`);
+  console.log(`   Available models: ${Object.keys(availableModels).length > 0 ? `${Object.values(availableModels).flat().length} models across ${Object.keys(availableModels).join(", ")}` : "none discovered"}`);
+  console.log(`   PID: ${process.pid}`);
 }
-async function dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds) {
-  const eventId = event._id.toString();
-  if (event.type === "agent.requestStart") {
-    if (processedCommandIds.has(eventId))
-      return;
-    processedCommandIds.set(eventId, Date.now());
-    await onRequestStartAgent(ctx, event);
-  } else if (event.type === "agent.requestStop") {
-    if (processedCommandIds.has(eventId))
-      return;
-    processedCommandIds.set(eventId, Date.now());
-    await onRequestStopAgent(ctx, event);
-  } else if (event.type === "daemon.ping") {
-    if (processedPingIds.has(eventId))
-      return;
-    processedPingIds.set(eventId, Date.now());
-    handlePing();
-    await ctx.deps.backend.mutation(api.machines.ackPing, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      pingEventId: event._id
-    });
+async function recoverState(ctx) {
+  console.log(`
+[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
+  try {
+    await recoverAgentState(ctx);
+  } catch (e) {
+    console.log(`   ⚠️  Recovery failed: ${e.message}`);
+    console.log(`   Continuing with fresh state`);
   }
 }
-async function startCommandLoop(ctx) {
-  let heartbeatCount = 0;
-  const heartbeatTimer = setInterval(() => {
-    ctx.deps.backend.mutation(api.machines.daemonHeartbeat, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId
-    }).then(() => {
-      heartbeatCount++;
-      console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
-    }).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${err.message}`);
-    });
-  }, DAEMON_HEARTBEAT_INTERVAL_MS);
-  heartbeatTimer.unref();
-  const shutdown = async () => {
-    console.log(`
-[${formatTimestamp()}] Shutting down...`);
-    clearInterval(heartbeatTimer);
-    await onDaemonShutdown(ctx);
-    releaseLock();
-    process.exit(0);
+async function initDaemon() {
+  if (!acquireLock()) {
+    process.exit(1);
+  }
+  const convexUrl = getConvexUrl();
+  const sessionId = validateAuthentication(convexUrl);
+  const client2 = await getConvexClient();
+  const typedSessionId = sessionId;
+  await validateSession(client2, typedSessionId, convexUrl);
+  const config3 = setupMachine();
+  const { machineId } = config3;
+  initHarnessRegistry();
+  const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
+  const availableModels = await registerCapabilities(client2, typedSessionId, config3, agentServices);
+  await connectDaemon(client2, typedSessionId, machineId, convexUrl);
+  const deps = createDefaultDeps16();
+  deps.backend.mutation = (endpoint, args) => client2.mutation(endpoint, args);
+  deps.backend.query = (endpoint, args) => client2.query(endpoint, args);
+  const events = new DaemonEventBus;
+  const ctx = {
+    client: client2,
+    sessionId: typedSessionId,
+    machineId,
+    config: config3,
+    deps,
+    events,
+    agentServices
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  process.on("SIGHUP", shutdown);
-  const wsClient2 = await getConvexWsClient();
-  console.log(`
-Listening for commands...`);
-  console.log(`Press Ctrl+C to stop
-`);
-  const processedCommandIds = new Map;
-  const processedPingIds = new Map;
-  wsClient2.onUpdate(api.machines.getCommandEvents, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId
-  }, async (result) => {
-    if (!result.events || result.events.length === 0)
-      return;
-    evictStaleDedupEntries(processedCommandIds, processedPingIds);
-    for (const event of result.events) {
-      try {
-        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
-        await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds);
-      } catch (err) {
-        console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
-      }
-    }
-  });
-  const modelRefreshTimer = setInterval(() => {
-    refreshModels(ctx).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Model refresh error: ${err.message}`);
-    });
-  }, MODEL_REFRESH_INTERVAL_MS);
-  modelRefreshTimer.unref();
-  return await new Promise(() => {});
+  registerEventListeners(ctx);
+  logStartup(ctx, availableModels);
+  await recoverState(ctx);
+  return ctx;
 }
-var MODEL_REFRESH_INTERVAL_MS;
-var init_command_loop = __esm(() => {
+var init_init2 = __esm(() => {
+  init_state_recovery();
   init_api3();
+  init_storage();
   init_client2();
   init_machine();
-  init_on_daemon_shutdown();
-  init_on_request_start_agent();
-  init_on_request_stop_agent();
+  init_intentional_stops();
+  init_remote_agents();
+  init_error_formatting();
+  init_version();
   init_pid();
-  MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+  init_register_listeners();
 });
 
-// src/commands/machine/daemon-start/handlers/state-recovery.ts
-async function recoverAgentState(ctx) {
-  const entries = ctx.deps.machine.listAgentEntries(ctx.machineId);
-  if (entries.length === 0) {
-    console.log(`   No agent entries found — nothing to recover`);
-    return;
-  }
-  let recovered = 0;
-  let cleared = 0;
-  for (const { chatroomId, role, entry } of entries) {
-    const { pid, harness } = entry;
-    const service = ctx.agentServices.get(harness) ?? ctx.agentServices.values().next().value;
-    const alive = service ? service.isAlive(pid) : false;
-    if (alive) {
-      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
-      recovered++;
-    } else {
-      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
-      await clearAgentPidEverywhere(ctx, chatroomId, role);
-      cleared++;
-    }
-  }
-  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
+// src/infrastructure/machine/stop-reason.ts
+function resolveStopReason(code2, signal, wasIntentional) {
+  if (wasIntentional)
+    return "user.stop";
+  if (signal !== null)
+    return "agent_process.signal";
+  if (code2 === 0)
+    return "agent_process.exited_clean";
+  return "agent_process.crashed";
 }
-var init_state_recovery = __esm(() => {
-  init_shared();
-});
 
-// src/events/daemon/event-bus.ts
-class DaemonEventBus {
-  listeners = new Map;
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set);
+// src/commands/machine/daemon-start/handlers/start-agent.ts
+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}`);
+  }
+  if (!workingDir) {
+    const msg2 = `No workingDir provided in command payload for ${chatroomId}/${role}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
+  }
+  console.log(`      Working dir: ${workingDir}`);
+  try {
+    const dirStat = await ctx.deps.fs.stat(workingDir);
+    if (!dirStat.isDirectory()) {
+      const msg2 = `Working directory is not a directory: ${workingDir}`;
+      console.log(`   ⚠️  ${msg2}`);
+      return { result: msg2, failed: true };
     }
-    this.listeners.get(event).add(listener);
-    return () => {
-      this.listeners.get(event)?.delete(listener);
-    };
+  } catch {
+    const msg2 = `Working directory does not exist: ${workingDir}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
   }
-  emit(event, payload) {
-    const set = this.listeners.get(event);
-    if (!set)
-      return;
-    for (const listener of set) {
-      try {
-        listener(payload);
-      } catch (err) {
-        console.warn(`[EventBus] Listener error on "${event}": ${err.message}`);
+  try {
+    const existingConfigs = await ctx.deps.backend.query(api.machines.getMachineAgentConfigs, {
+      sessionId: ctx.sessionId,
+      chatroomId
+    });
+    const existingConfig = existingConfigs.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
+    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: ${pid2}) — stopping before respawn`);
+        await onAgentShutdown(ctx, { chatroomId, role, pid: pid2, stopReason: "daemon.respawn" });
+        console.log(`   ✅ Existing agent stopped (PID: ${pid2})`);
       }
     }
+  } catch (e) {
+    console.log(`   ⚠️  Could not check for existing agent (proceeding): ${e.message}`);
   }
-  removeAllListeners() {
-    this.listeners.clear();
+  const convexUrl = getConvexUrl();
+  const initPromptResult = await ctx.deps.backend.query(api.messages.getInitPrompt, {
+    sessionId: ctx.sessionId,
+    chatroomId,
+    role,
+    convexUrl
+  });
+  if (!initPromptResult?.prompt) {
+    const msg2 = "Failed to fetch init prompt from backend";
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
   }
-}
-
-// src/events/daemon/agent/on-agent-exited.ts
-function onAgentExited(ctx, payload) {
-  const { chatroomId, role, pid, code: code2, signal, stopReason, intentional } = payload;
-  const ts = formatTimestamp();
-  console.log(`[${ts}] Agent stopped: ${stopReason} (${role})`);
-  const isDaemonRespawn = stopReason === "daemon_respawn_stop";
-  const isIntentional = intentional && !isDaemonRespawn;
-  if (isIntentional) {
-    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})`);
-  } else {
-    console.log(`[${ts}] ⚠️  Agent process exited ` + `(PID: ${pid}, role: ${role}, code: ${code2}, signal: ${signal})`);
+  console.log(`   Fetched split init prompt from backend`);
+  const service = ctx.agentServices.get(agentHarness);
+  if (!service) {
+    const msg2 = `Unknown agent harness: ${agentHarness}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
   }
-  ctx.deps.backend.mutation(api.machines.recordAgentExited, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId,
+  let spawnResult;
+  try {
+    spawnResult = await service.spawn({
+      workingDir,
+      prompt: initPromptResult.initialMessage,
+      systemPrompt: initPromptResult.rolePrompt,
+      model,
+      context: { machineId: ctx.machineId, chatroomId, role }
+    });
+  } catch (e) {
+    const msg2 = `Failed to spawn agent: ${e.message}`;
+    console.log(`   ⚠️  ${msg2}`);
+    return { result: msg2, failed: true };
+  }
+  const { pid } = spawnResult;
+  const msg = `Agent spawned (PID: ${pid})`;
+  console.log(`   ✅ ${msg}`);
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid,
+      model
+    });
+    console.log(`   Updated backend with PID: ${pid}`);
+    ctx.deps.machine.persistAgentPid(ctx.machineId, chatroomId, role, pid, agentHarness);
+  } catch (e) {
+    console.log(`   ⚠️  Failed to update PID in backend: ${e.message}`);
+  }
+  ctx.events.emit("agent:started", {
     chatroomId,
     role,
     pid,
-    intentional,
-    stopReason,
-    stopSignal: stopReason === "process_terminated_with_signal" ? signal ?? undefined : undefined,
-    exitCode: code2 ?? undefined,
-    signal: signal ?? undefined
-  }).catch((err) => {
-    console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
+    harness: agentHarness,
+    model
   });
-  ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
-  for (const service of ctx.agentServices.values()) {
-    service.untrack(pid);
+  spawnResult.onExit(({ code: code2, signal }) => {
+    const pendingReason = ctx.deps.stops.consume(chatroomId, role);
+    const stopReason = pendingReason ?? resolveStopReason(code2, signal, false);
+    ctx.events.emit("agent:exited", {
+      chatroomId,
+      role,
+      pid,
+      code: code2,
+      signal,
+      stopReason,
+      intentional: pendingReason !== null
+    });
+  });
+  if (spawnResult.onAgentEnd) {
+    spawnResult.onAgentEnd(() => {
+      try {
+        ctx.deps.processes.kill(-pid, "SIGTERM");
+      } catch {}
+    });
   }
+  let lastReportedTokenAt = 0;
+  spawnResult.onOutput(() => {
+    const now = Date.now();
+    if (now - lastReportedTokenAt >= 30000) {
+      lastReportedTokenAt = now;
+      ctx.deps.backend.mutation(api.participants.updateTokenActivity, {
+        sessionId: ctx.sessionId,
+        chatroomId,
+        role
+      }).catch(() => {});
+    }
+  });
+  return { result: msg, failed: false };
 }
-var init_on_agent_exited = __esm(() => {
+var init_start_agent = __esm(() => {
   init_api3();
+  init_client2();
 });
 
-// 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) => 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();
-    }
-  };
+// 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
+  });
 }
-var init_register_listeners = __esm(() => {
-  init_on_agent_exited();
-  init_on_agent_started();
-  init_on_agent_stopped();
+var init_on_request_start_agent = __esm(() => {
+  init_start_agent();
 });
 
-// src/commands/machine/daemon-start/init.ts
-import { stat } from "node:fs/promises";
-async function discoverModels(agentServices) {
-  const results = {};
-  for (const [harness, service] of agentServices) {
-    if (service.isInstalled()) {
-      try {
-        results[harness] = await service.listModels();
-      } catch {
-        results[harness] = [];
-      }
-    }
+// src/commands/machine/daemon-start/handlers/stop-agent.ts
+async function executeStopAgent(ctx, args) {
+  const { chatroomId, role, reason } = args;
+  const stopReason = reason;
+  console.log(`   ↪ stop-agent command received`);
+  console.log(`      Chatroom: ${chatroomId}`);
+  console.log(`      Role: ${role}`);
+  console.log(`      Reason: ${reason}`);
+  const configsResult = await ctx.deps.backend.query(api.machines.getMachineAgentConfigs, {
+    sessionId: ctx.sessionId,
+    chatroomId
+  });
+  const targetConfig = configsResult.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
+  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 };
   }
-  return results;
-}
-function createDefaultDeps16() {
-  return {
-    backend: {
-      mutation: async () => {
-        throw new Error("Backend not initialized");
-      },
-      query: async () => {
-        throw new Error("Backend not initialized");
-      }
-    },
-    processes: {
-      kill: (pid, signal) => process.kill(pid, signal)
-    },
-    fs: {
-      stat
-    },
-    stops: {
-      mark: markIntentionalStop,
-      consume: consumeIntentionalStop,
-      clear: clearIntentionalStop
-    },
-    machine: {
-      clearAgentPid,
-      persistAgentPid,
-      listAgentEntries,
-      persistEventCursor,
-      loadEventCursor
-    },
-    clock: {
-      now: () => Date.now(),
-      delay: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+  const anyService = ctx.agentServices.values().next().value;
+  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;
     }
-  };
-}
-function validateAuthentication(convexUrl) {
-  const sessionId = getSessionId();
-  if (!sessionId) {
-    const otherUrls = getOtherSessionUrls();
-    console.error(`❌ Not authenticated for: ${convexUrl}`);
-    if (otherUrls.length > 0) {
-      console.error(`
-\uD83D\uDCA1 You have sessions for other environments:`);
-      for (const url of otherUrls) {
-        console.error(`   • ${url}`);
+    try {
+      const shutdownResult = await onAgentShutdown(ctx, {
+        chatroomId,
+        role,
+        pid,
+        stopReason
+      });
+      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}`);
     }
-    console.error(`
-Run: chatroom auth login`);
-    releaseLock();
-    process.exit(1);
   }
-  return sessionId;
+  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 };
 }
-async function validateSession(client2, sessionId, convexUrl) {
-  const validation = await client2.query(api.cliAuth.validateSession, { sessionId });
-  if (!validation.valid) {
-    console.error(`❌ Session invalid: ${validation.reason}`);
-    console.error(`
-Run: chatroom auth login`);
-    releaseLock();
-    process.exit(1);
+var init_stop_agent = __esm(() => {
+  init_api3();
+  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
+  });
 }
-function setupMachine() {
-  ensureMachineRegistered();
-  const config3 = loadMachineConfig();
-  return config3;
+var init_on_request_stop_agent = __esm(() => {
+  init_stop_agent();
+});
+
+// src/commands/machine/daemon-start/handlers/ping.ts
+function handlePing() {
+  console.log(`   ↪ Responding: pong`);
+  return { result: "pong", failed: false };
 }
-async function registerCapabilities(client2, sessionId, config3, agentServices) {
-  const { machineId } = config3;
-  const availableModels = await discoverModels(agentServices);
+
+// src/commands/machine/daemon-start/command-loop.ts
+async function refreshModels(ctx) {
+  if (!ctx.config)
+    return;
+  const models = await discoverModels(ctx.agentServices);
+  const freshConfig = ensureMachineRegistered();
+  ctx.config.availableHarnesses = freshConfig.availableHarnesses;
+  ctx.config.harnessVersions = freshConfig.harnessVersions;
+  const totalCount = Object.values(models).flat().length;
   try {
-    await client2.mutation(api.machines.register, {
-      sessionId,
-      machineId,
-      hostname: config3.hostname,
-      os: config3.os,
-      availableHarnesses: config3.availableHarnesses,
-      harnessVersions: config3.harnessVersions,
-      availableModels
+    await ctx.deps.backend.mutation(api.machines.refreshCapabilities, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      availableHarnesses: ctx.config.availableHarnesses,
+      harnessVersions: ctx.config.harnessVersions,
+      availableModels: models
     });
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh: ${totalCount > 0 ? `${totalCount} models` : "none discovered"}`);
   } catch (error) {
-    console.warn(`⚠️  Machine registration update failed: ${error.message}`);
+    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
   }
-  return availableModels;
 }
-async function connectDaemon(client2, sessionId, machineId, convexUrl) {
-  try {
-    await client2.mutation(api.machines.updateDaemonStatus, {
-      sessionId,
-      machineId,
-      connected: true
-    });
-  } catch (error) {
-    if (isNetworkError(error)) {
-      formatConnectivityError(error, convexUrl);
-    } else {
-      console.error(`❌ Failed to update daemon status: ${error.message}`);
-    }
-    releaseLock();
-    process.exit(1);
+function evictStaleDedupEntries(processedCommandIds, processedPingIds) {
+  const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
+  for (const [id, ts] of processedCommandIds) {
+    if (ts < evictBefore)
+      processedCommandIds.delete(id);
   }
-}
-function logStartup(ctx, availableModels) {
-  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
-  console.log(`   CLI version: ${getVersion()}`);
-  console.log(`   Machine ID: ${ctx.machineId}`);
-  console.log(`   Hostname: ${ctx.config?.hostname ?? "unknown"}`);
-  console.log(`   Available harnesses: ${ctx.config?.availableHarnesses.join(", ") || "none"}`);
-  console.log(`   Available models: ${Object.keys(availableModels).length > 0 ? `${Object.values(availableModels).flat().length} models across ${Object.keys(availableModels).join(", ")}` : "none discovered"}`);
-  console.log(`   PID: ${process.pid}`);
-}
-async function recoverState(ctx) {
-  console.log(`
-[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
-  try {
-    await recoverAgentState(ctx);
-  } catch (e) {
-    console.log(`   ⚠️  Recovery failed: ${e.message}`);
-    console.log(`   Continuing with fresh state`);
+  for (const [id, ts] of processedPingIds) {
+    if (ts < evictBefore)
+      processedPingIds.delete(id);
   }
 }
-async function initDaemon() {
-  if (!acquireLock()) {
-    process.exit(1);
+async function dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds) {
+  const eventId = event._id.toString();
+  if (event.type === "agent.requestStart") {
+    if (processedCommandIds.has(eventId))
+      return;
+    processedCommandIds.set(eventId, Date.now());
+    await onRequestStartAgent(ctx, event);
+  } else if (event.type === "agent.requestStop") {
+    if (processedCommandIds.has(eventId))
+      return;
+    processedCommandIds.set(eventId, Date.now());
+    await onRequestStopAgent(ctx, event);
+  } else if (event.type === "daemon.ping") {
+    if (processedPingIds.has(eventId))
+      return;
+    processedPingIds.set(eventId, Date.now());
+    handlePing();
+    await ctx.deps.backend.mutation(api.machines.ackPing, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      pingEventId: event._id
+    });
   }
-  const convexUrl = getConvexUrl();
-  const sessionId = validateAuthentication(convexUrl);
-  const client2 = await getConvexClient();
-  const typedSessionId = sessionId;
-  await validateSession(client2, typedSessionId, convexUrl);
-  const config3 = setupMachine();
-  const { machineId } = config3;
-  const openCodeService = new OpenCodeAgentService;
-  const piService = new PiAgentService;
-  const agentServices = new Map([
-    ["opencode", openCodeService],
-    ["pi", piService]
-  ]);
-  const availableModels = await registerCapabilities(client2, typedSessionId, config3, agentServices);
-  await connectDaemon(client2, typedSessionId, machineId, convexUrl);
-  const deps = createDefaultDeps16();
-  deps.backend.mutation = (endpoint, args) => client2.mutation(endpoint, args);
-  deps.backend.query = (endpoint, args) => client2.query(endpoint, args);
-  const events = new DaemonEventBus;
-  const ctx = {
-    client: client2,
-    sessionId: typedSessionId,
-    machineId,
-    config: config3,
-    deps,
-    events,
-    agentServices
+}
+async function startCommandLoop(ctx) {
+  let heartbeatCount = 0;
+  const heartbeatTimer = setInterval(() => {
+    ctx.deps.backend.mutation(api.machines.daemonHeartbeat, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    }).then(() => {
+      heartbeatCount++;
+      console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
+    }).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${err.message}`);
+    });
+  }, DAEMON_HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref();
+  const shutdown = async () => {
+    console.log(`
+[${formatTimestamp()}] Shutting down...`);
+    clearInterval(heartbeatTimer);
+    await onDaemonShutdown(ctx);
+    releaseLock();
+    process.exit(0);
   };
-  registerEventListeners(ctx);
-  logStartup(ctx, availableModels);
-  await recoverState(ctx);
-  return ctx;
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
+  const wsClient2 = await getConvexWsClient();
+  console.log(`
+Listening for commands...`);
+  console.log(`Press Ctrl+C to stop
+`);
+  const processedCommandIds = new Map;
+  const processedPingIds = new Map;
+  wsClient2.onUpdate(api.machines.getCommandEvents, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  }, async (result) => {
+    if (!result.events || result.events.length === 0)
+      return;
+    evictStaleDedupEntries(processedCommandIds, processedPingIds);
+    for (const event of result.events) {
+      try {
+        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
+        await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds);
+      } catch (err) {
+        console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
+      }
+    }
+  });
+  const modelRefreshTimer = setInterval(() => {
+    refreshModels(ctx).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️  Model refresh error: ${err.message}`);
+    });
+  }, MODEL_REFRESH_INTERVAL_MS);
+  modelRefreshTimer.unref();
+  return await new Promise(() => {});
 }
-var init_init2 = __esm(() => {
-  init_state_recovery();
+var MODEL_REFRESH_INTERVAL_MS;
+var init_command_loop = __esm(() => {
   init_api3();
-  init_storage();
   init_client2();
   init_machine();
-  init_intentional_stops();
-  init_opencode();
-  init_pi();
-  init_error_formatting();
-  init_version();
+  init_on_daemon_shutdown();
+  init_init2();
+  init_on_request_start_agent();
+  init_on_request_stop_agent();
   init_pid();
-  init_register_listeners();
+  MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/index.ts
@@ -14711,8 +14841,8 @@ __export(exports_opencode_install, {
 });
 async function isChatroomInstalledDefault() {
   try {
-    const { execSync: execSync3 } = await import("child_process");
-    execSync3("chatroom --version", { stdio: "pipe" });
+    const { execSync: execSync2 } = await import("child_process");
+    execSync2("chatroom --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;