chatroom-cli 1.43.2 → 1.44.0

package/dist/index.js

@@ -27123,6 +27123,207 @@ var init_claude = __esm(() => {
   init_claude_code_agent_service();
 });
 
+// src/infrastructure/services/remote-agents/commandcode/command-code-stream-reader.ts
+import { createInterface as createInterface5 } from "node:readline";
+
+class CommandCodeStreamReader {
+  textCallbacks = [];
+  agentEndCallbacks = [];
+  anyEventCallbacks = [];
+  constructor(stream) {
+    const rl = createInterface5({ input: stream, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed)
+        return;
+      for (const cb of this.anyEventCallbacks)
+        cb();
+      for (const cb of this.textCallbacks)
+        cb(trimmed);
+    });
+    stream.on("close", () => {
+      for (const cb of this.agentEndCallbacks)
+        cb();
+    });
+  }
+  onText(cb) {
+    this.textCallbacks.push(cb);
+  }
+  onAnyEvent(cb) {
+    this.anyEventCallbacks.push(cb);
+  }
+  onAgentEnd(cb) {
+    this.agentEndCallbacks.push(cb);
+  }
+}
+var init_command_code_stream_reader = () => {};
+
+// src/infrastructure/services/remote-agents/commandcode/command-code-agent-service.ts
+var COMMANDCODE_COMMAND = "cmd", COMMANDCODE_MODELS, CommandCodeAgentService;
+var init_command_code_agent_service = __esm(() => {
+  init_base_cli_agent_service();
+  init_command_code_stream_reader();
+  COMMANDCODE_MODELS = [
+    "claude-sonnet-4-6",
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-haiku-4-5",
+    "gpt-5.5",
+    "gpt-5.4",
+    "gpt-5.3-codex",
+    "gpt-5.4-mini",
+    "google/gemini-3.5-flash",
+    "google/gemini-3.1-flash-lite",
+    "moonshotai/Kimi-K2.6",
+    "moonshotai/Kimi-K2.5",
+    "zai-org/GLM-5.1",
+    "zai-org/GLM-5",
+    "MiniMaxAI/MiniMax-M2.7",
+    "MiniMaxAI/MiniMax-M2.5",
+    "deepseek/deepseek-v4-pro",
+    "deepseek/deepseek-v4-flash",
+    "Qwen/Qwen3.6-Max-Preview",
+    "Qwen/Qwen3.6-Plus",
+    "Qwen/Qwen3.7-Max",
+    "stepfun/Step-3.5-Flash"
+  ];
+  CommandCodeAgentService = class CommandCodeAgentService extends BaseCLIAgentService {
+    id = "commandcode";
+    displayName = "CommandCode";
+    command = COMMANDCODE_COMMAND;
+    constructor(deps) {
+      super(deps);
+    }
+    async isInstalled() {
+      return this.checkInstalled(COMMANDCODE_COMMAND);
+    }
+    async getVersion() {
+      return this.checkVersion(COMMANDCODE_COMMAND);
+    }
+    async listModels() {
+      return COMMANDCODE_MODELS;
+    }
+    async spawn(options) {
+      const args2 = ["-p", "--skip-onboarding", "--yolo", "--max-turns", "999999"];
+      if (options.model) {
+        args2.push("--model", options.model);
+      }
+      const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
+
+${options.prompt}` : options.prompt;
+      const childProcess = this.deps.spawn(COMMANDCODE_COMMAND, args2, {
+        cwd: options.workingDir,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: true,
+        env: {
+          ...process.env,
+          GIT_EDITOR: "true",
+          GIT_SEQUENCE_EDITOR: "true"
+        }
+      });
+      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 context4 = options.context;
+      const entry = this.registerProcess(pid, context4);
+      const roleTag = context4.role ?? "unknown";
+      const chatroomSuffix = context4.chatroomId ? `@${context4.chatroomId.slice(-6)}` : "";
+      const logPrefix = `[commandcode:${roleTag}${chatroomSuffix}`;
+      const outputCallbacks = [];
+      if (childProcess.stdout) {
+        const reader = new CommandCodeStreamReader(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]
+`);
+        });
+        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: context4 });
+            });
+          },
+          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: context4 });
+          });
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        }
+      };
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/commandcode/index.ts
+var init_commandcode = __esm(() => {
+  init_command_code_agent_service();
+});
+
 // ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/types.gen.js
 var init_types_gen = () => {};
 
@@ -29517,12 +29718,14 @@ function initHarnessRegistry() {
   registerHarness(new PiAgentService);
   registerHarness(new CursorAgentService);
   registerHarness(new ClaudeCodeAgentService);
+  registerHarness(new CommandCodeAgentService);
   registerHarness(new CopilotAgentService);
   initialized = true;
 }
 var initialized = false;
 var init_init_registry = __esm(() => {
   init_claude();
+  init_commandcode();
   init_copilot();
   init_cursor();
   init_opencode();
@@ -69493,6 +69696,7 @@ var init_errorCodes = __esm(() => {
     COMMAND_NOT_RUNNING: "COMMAND_NOT_RUNNING",
     TOO_MANY_COMMANDS: "TOO_MANY_COMMANDS",
     INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION",
+    INVALID_RUN_STATE_TRANSITION: "INVALID_RUN_STATE_TRANSITION",
     OUTPUT_CHUNK_TOO_LARGE: "OUTPUT_CHUNK_TOO_LARGE",
     NOT_FOUND: "NOT_FOUND",
     INVALID_BOT_TOKEN: "INVALID_BOT_TOKEN",
@@ -69573,6 +69777,7 @@ var init_errorCodes = __esm(() => {
     BACKEND_ERROR_CODES.INVALID_STDIN_FORMAT,
     BACKEND_ERROR_CODES.INVALID_BOT_TOKEN,
     BACKEND_ERROR_CODES.INVALID_STATE_TRANSITION,
+    BACKEND_ERROR_CODES.INVALID_RUN_STATE_TRANSITION,
     BACKEND_ERROR_CODES.TASK_INVALID_TRANSITION,
     BACKEND_ERROR_CODES.TASK_MISSING_REQUIRED_FIELD,
     BACKEND_ERROR_CODES.TASK_VALIDATION_FAILED,
@@ -75936,31 +76141,248 @@ var init_file_tree_subscription = __esm(() => {
   init_convex_error();
 });
 
-// src/commands/machine/daemon-start/handlers/command-runner.ts
-import { spawn as spawn4 } from "node:child_process";
-import { access as access3 } from "node:fs/promises";
-function evictStalePendingStops() {
-  const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
-  for (const [runId, ts] of pendingStops) {
-    if (ts < evictBefore)
-      pendingStops.delete(runId);
+// src/commands/machine/daemon-start/handlers/orphan-tracker.ts
+import { createHash as createHash6 } from "node:crypto";
+import {
+  appendFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync5,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join15 } from "node:path";
+function getUrlHash2() {
+  const url2 = getConvexUrl();
+  return createHash6("sha256").update(url2).digest("hex").substring(0, 8);
+}
+function getChildPidsFilePath() {
+  const dir = join15(homedir6(), ".chatroom");
+  return join15(dir, `daemon-children-${getUrlHash2()}.pids`);
+}
+function ensureChatroomDir3() {
+  const dir = join15(homedir6(), ".chatroom");
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true, mode: 448 });
   }
 }
-function buildCommandKey(machineId, workingDir, commandName) {
-  return `${machineId}|${workingDir}|${commandName}`;
+function readPids() {
+  const filePath = getChildPidsFilePath();
+  if (!existsSync3(filePath))
+    return [];
+  try {
+    return readFileSync5(filePath, "utf-8").split(`
+`).map((line) => parseInt(line.trim(), 10)).filter((n) => Number.isFinite(n) && n > 0);
+  } catch {
+    return [];
+  }
 }
-async function reportRunFailed(ctx, runId, reason) {
+function trackChildPid(pid) {
   try {
-    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      runId,
-      status: "failed"
+    ensureChatroomDir3();
+    appendFileSync(getChildPidsFilePath(), `${pid}
+`, "utf-8");
+  } catch (err) {
+    console.warn(`[orphan-tracker] Failed to track child PID ${pid}: ${err}`);
+  }
+}
+function untrackChildPid(pid) {
+  try {
+    const filePath = getChildPidsFilePath();
+    if (!existsSync3(filePath))
+      return;
+    const remaining = readFileSync5(filePath, "utf-8").split(`
+`).filter((line) => {
+      const n = parseInt(line.trim(), 10);
+      return Number.isFinite(n) && n > 0 && n !== pid;
     });
+    const tmpPath = `${filePath}.tmp`;
+    writeFileSync3(tmpPath, remaining.join(`
+`) + (remaining.length > 0 ? `
+` : ""), "utf-8");
+    renameSync(tmpPath, filePath);
   } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to report run failure (${reason}): ${getErrorMessage(err)}`);
+    console.warn(`[orphan-tracker] Failed to untrack child PID ${pid}: ${err}`);
   }
 }
+function clearTrackedPids() {
+  try {
+    const filePath = getChildPidsFilePath();
+    if (existsSync3(filePath)) {
+      unlinkSync2(filePath);
+    }
+  } catch {}
+}
+async function reapOrphanedProcessGroups() {
+  const pids = readPids();
+  let reaped = 0;
+  const checked = pids.length;
+  for (const pgid of pids) {
+    if (process.platform === "win32")
+      continue;
+    try {
+      process.kill(-pgid, 0);
+    } catch {
+      continue;
+    }
+    try {
+      process.kill(-pgid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    const deadline = Date.now() + 500;
+    let alive = true;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 50));
+      try {
+        process.kill(-pgid, 0);
+      } catch {
+        alive = false;
+        break;
+      }
+    }
+    if (alive) {
+      try {
+        process.kill(-pgid, "SIGKILL");
+      } catch {}
+    }
+    console.log(`[orphan-tracker] Reaped orphan process group ${pgid}`);
+    reaped++;
+  }
+  clearTrackedPids();
+  return { reaped, checked };
+}
+var CHATROOM_DIR5;
+var init_orphan_tracker = __esm(() => {
+  init_client2();
+  CHATROOM_DIR5 = join15(homedir6(), ".chatroom");
+});
+
+// src/commands/machine/daemon-start/handlers/process/state.ts
+function deriveTerminalStatus(code2, signal, terminationIntent) {
+  if (terminationIntent !== null)
+    return terminationIntent;
+  if (code2 === 0)
+    return "completed";
+  if (signal !== null)
+    return "stopped";
+  return "failed";
+}
+var TERMINAL_STATES, PENDING_STOP_TTL_MS = 60000, SIGTERM_GRACE_PERIOD_MS = 5000, SOFT_TIMEOUT_MS, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE;
+var init_state2 = __esm(() => {
+  TERMINAL_STATES = new Set(["completed", "failed", "stopped", "killed"]);
+  SOFT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+  MAX_BUFFER_SIZE = 100 * 1024;
+});
+
+// src/commands/machine/daemon-start/handlers/process/manager.ts
+class ProcessManager {
+  runningProcesses = new Map;
+  runningProcessesByCommand = new Map;
+  pendingStops = new Map;
+  has(runId) {
+    return this.runningProcesses.has(runId);
+  }
+  get(runId) {
+    return this.runningProcesses.get(runId);
+  }
+  getByCommand(commandKey) {
+    const runId = this.runningProcessesByCommand.get(commandKey);
+    if (runId === undefined)
+      return;
+    return this.runningProcesses.get(runId);
+  }
+  getAll() {
+    return [...this.runningProcesses.entries()];
+  }
+  get size() {
+    return this.runningProcesses.size;
+  }
+  register(runId, commandKey, process2) {
+    this.runningProcesses.set(runId, process2);
+    this.runningProcessesByCommand.set(commandKey, runId);
+  }
+  unregister(runId, commandKey) {
+    this.runningProcesses.delete(runId);
+    if (this.runningProcessesByCommand.get(commandKey) === runId) {
+      this.runningProcessesByCommand.delete(commandKey);
+    }
+  }
+  markPendingStop(runId) {
+    this.pendingStops.set(runId, Date.now());
+  }
+  hasPendingStop(runId) {
+    return this.pendingStops.has(runId);
+  }
+  consumePendingStop(runId) {
+    const has5 = this.pendingStops.has(runId);
+    if (has5)
+      this.pendingStops.delete(runId);
+    return has5;
+  }
+  evictStalePendingStops() {
+    const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
+    for (const [runId, ts] of this.pendingStops) {
+      if (ts < evictBefore)
+        this.pendingStops.delete(runId);
+    }
+  }
+  clear() {
+    this.runningProcesses.clear();
+    this.runningProcessesByCommand.clear();
+    this.pendingStops.clear();
+  }
+  waitForExit(runId, ms) {
+    return new Promise((resolve5) => {
+      const interval = 100;
+      let elapsed3 = 0;
+      const timer = setInterval(() => {
+        if (!this.runningProcesses.has(runId)) {
+          clearInterval(timer);
+          resolve5(true);
+          return;
+        }
+        elapsed3 += interval;
+        if (elapsed3 >= ms) {
+          clearInterval(timer);
+          resolve5(false);
+        }
+      }, interval);
+    });
+  }
+}
+var processManager;
+var init_manager = __esm(() => {
+  init_state2();
+  processManager = new ProcessManager;
+});
+
+// src/commands/machine/daemon-start/handlers/process/killer.ts
+function killProcess(child, signal) {
+  if (child.pid == null)
+    return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch {}
+}
+async function killTrackedProcess(tracked) {
+  killProcess(tracked.process, "SIGTERM");
+  const exited = await processManager.waitForExit(tracked.runId, SIGTERM_GRACE_PERIOD_MS);
+  if (!exited) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${tracked.runId}`);
+    killProcess(tracked.process, "SIGKILL");
+    await processManager.waitForExit(tracked.runId, 1000);
+  }
+}
+var init_killer = __esm(() => {
+  init_state2();
+  init_manager();
+});
+
+// src/commands/machine/daemon-start/handlers/process/spawner.ts
+import { spawn as spawn4 } from "node:child_process";
 async function flushOutput(ctx, tracked) {
   if (tracked.outputBuffer.length === 0)
     return;
@@ -75986,91 +76408,14 @@ function appendToBuffer(ctx, tracked, data) {
     flushOutput(ctx, tracked).catch(() => {});
   }
 }
-function killProcess(child, signal) {
-  try {
-    child.kill(signal);
-  } catch {}
-}
-function waitForExit(runIdStr, ms) {
-  return new Promise((resolve5) => {
-    const interval = 100;
-    let elapsed3 = 0;
-    const timer = setInterval(() => {
-      if (!runningProcesses.has(runIdStr)) {
-        clearInterval(timer);
-        resolve5(true);
-        return;
-      }
-      elapsed3 += interval;
-      if (elapsed3 >= ms) {
-        clearInterval(timer);
-        resolve5(false);
-      }
-    }, interval);
-  });
-}
-async function killTrackedProcess(tracked) {
-  killProcess(tracked.process, "SIGTERM");
-  const exited = await waitForExit(tracked.runId, SIGTERM_GRACE_PERIOD_MS);
-  if (!exited) {
-    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${tracked.runId}`);
-    killProcess(tracked.process, "SIGKILL");
-    await waitForExit(tracked.runId, 1000);
-  }
-}
-async function onCommandRun(ctx, event) {
+function spawnCommandProcess(ctx, event, commandKey) {
   const { workingDir, commandName, script, runId } = event;
   const runIdStr = runId.toString();
-  const commandKey = buildCommandKey(ctx.machineId, workingDir, commandName);
-  if (runningProcesses.has(runIdStr)) {
-    console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
-    return;
-  }
-  if (pendingStops.has(runIdStr)) {
-    pendingStops.delete(runIdStr);
-    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
-    try {
-      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId,
-        runId,
-        status: "stopped"
-      });
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
-    }
-    return;
-  }
-  const priorRunId = runningProcessesByCommand.get(commandKey);
-  if (priorRunId) {
-    const priorTracked = runningProcesses.get(priorRunId);
-    if (priorTracked) {
-      console.log(`[${formatTimestamp()}] \uD83D\uDD04 Replacing prior run ${priorRunId} with ${runIdStr} for ${commandName}`);
-      clearInterval(priorTracked.flushTimer);
-      if (priorTracked.softTimeoutTimer)
-        clearTimeout(priorTracked.softTimeoutTimer);
-      await killTrackedProcess(priorTracked);
-      runningProcesses.delete(priorRunId);
-      runningProcessesByCommand.delete(commandKey);
-    }
-  }
-  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
-  if (!workingDir.startsWith("/")) {
-    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
-    await reportRunFailed(ctx, runId, "Working directory is not an absolute path");
-    return;
-  }
-  try {
-    await access3(workingDir);
-  } catch {
-    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir not found: ${workingDir}`);
-    await reportRunFailed(ctx, runId, "Working directory not found");
-    return;
-  }
   const child = spawn4("sh", ["-c", script], {
     cwd: workingDir,
     env: { ...process.env },
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
   });
   const tracked = {
     process: child,
@@ -76081,16 +76426,20 @@ async function onCommandRun(ctx, event) {
     flushTimer: setInterval(() => {
       flushOutput(ctx, tracked).catch(() => {});
     }, OUTPUT_FLUSH_INTERVAL_MS),
-    softTimeoutTimer: null
+    softTimeoutTimer: null,
+    terminationIntent: null
   };
   tracked.flushTimer.unref?.();
-  runningProcesses.set(runIdStr, tracked);
-  runningProcessesByCommand.set(commandKey, runIdStr);
+  processManager.register(runIdStr, commandKey, tracked);
+  if (child.pid != null) {
+    trackChildPid(child.pid);
+  }
   const softTimeoutTimer = setTimeout(async () => {
     console.log(`[${formatTimestamp()}] ⏰ Command soft timeout (24h): ${commandName} (runId: ${runIdStr})`);
-    const currentTracked = runningProcesses.get(runIdStr);
+    const currentTracked = processManager.get(runIdStr);
     if (!currentTracked)
       return;
+    currentTracked.terminationIntent = "killed";
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76104,7 +76453,7 @@ async function onCommandRun(ctx, event) {
     }
     killProcess(child, "SIGTERM");
     setTimeout(() => {
-      if (!runningProcesses.has(runIdStr))
+      if (!processManager.has(runIdStr))
         return;
       console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
       killProcess(child, "SIGKILL");
@@ -76112,17 +76461,6 @@ async function onCommandRun(ctx, event) {
   }, SOFT_TIMEOUT_MS);
   softTimeoutTimer.unref?.();
   tracked.softTimeoutTimer = softTimeoutTimer;
-  try {
-    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      runId,
-      status: "running",
-      pid: child.pid
-    });
-  } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status to running: ${getErrorMessage(err)}`);
-  }
   child.stdout?.on("data", (data) => {
     appendToBuffer(ctx, tracked, data.toString());
   });
@@ -76132,14 +76470,14 @@ async function onCommandRun(ctx, event) {
   child.on("exit", async (code2, signal) => {
     console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     await flushOutput(ctx, tracked).catch(() => {});
+    if (tracked.process.pid != null) {
+      untrackChildPid(tracked.process.pid);
+    }
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    runningProcesses.delete(runIdStr);
-    if (runningProcessesByCommand.get(commandKey) === runIdStr) {
-      runningProcessesByCommand.delete(commandKey);
-    }
-    const status3 = code2 === 0 ? "completed" : signal ? "stopped" : "failed";
+    processManager.unregister(runIdStr, commandKey);
+    const status3 = deriveTerminalStatus(code2, signal, tracked.terminationIntent);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76154,13 +76492,13 @@ async function onCommandRun(ctx, event) {
   });
   child.on("error", async (err) => {
     console.error(`[${formatTimestamp()}] ❌ Command spawn failed: ${commandName}: ${err.message}`);
+    if (tracked.process.pid != null) {
+      untrackChildPid(tracked.process.pid);
+    }
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    runningProcesses.delete(runIdStr);
-    if (runningProcessesByCommand.get(commandKey) === runIdStr) {
-      runningProcessesByCommand.delete(commandKey);
-    }
+    processManager.unregister(runIdStr, commandKey);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76172,13 +76510,111 @@ async function onCommandRun(ctx, event) {
       console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status on error: ${getErrorMessage(updateErr)}`);
     }
   });
+  return tracked;
+}
+var init_spawner = __esm(() => {
+  init_api3();
+  init_convex_error();
+  init_orphan_tracker();
+  init_state2();
+  init_manager();
+  init_killer();
+});
+
+// src/commands/machine/daemon-start/handlers/command-runner.ts
+import { access as access3 } from "node:fs/promises";
+function buildCommandKey(machineId, workingDir, commandName) {
+  return `${machineId}|${workingDir}|${commandName}`;
+}
+async function reportRunFailed(ctx, runId, reason) {
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId,
+      status: "failed"
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to report run failure (${reason}): ${getErrorMessage(err)}`);
+  }
+}
+async function onCommandRun(ctx, event) {
+  const { workingDir, commandName, script, runId } = event;
+  const runIdStr = runId.toString();
+  const commandKey = buildCommandKey(ctx.machineId, workingDir, commandName);
+  if (processManager.has(runIdStr)) {
+    console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
+    return;
+  }
+  if (processManager.consumePendingStop(runIdStr)) {
+    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId,
+        status: "stopped"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
+    }
+    return;
+  }
+  try {
+    const currentRun = await ctx.deps.backend.query(api.commands.getRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId
+    });
+    if (currentRun && TERMINAL_STATES.has(currentRun.status)) {
+      console.log(`[${formatTimestamp()}] ⏭️ Skipping command run — row already ${currentRun.status}: ${commandName} (${runIdStr})`);
+      return;
+    }
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to check run status before spawn: ${getErrorMessage(err)}`);
+  }
+  const priorTracked = processManager.getByCommand(commandKey);
+  if (priorTracked) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Replacing prior run ${priorTracked.runId} with ${runIdStr} for ${commandName}`);
+    priorTracked.terminationIntent = "killed";
+    clearInterval(priorTracked.flushTimer);
+    if (priorTracked.softTimeoutTimer)
+      clearTimeout(priorTracked.softTimeoutTimer);
+    await killTrackedProcess(priorTracked);
+    processManager.unregister(priorTracked.runId, commandKey);
+  }
+  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
+  if (!workingDir.startsWith("/")) {
+    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
+    await reportRunFailed(ctx, runId, "Working directory is not an absolute path");
+    return;
+  }
+  try {
+    await access3(workingDir);
+  } catch {
+    console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir not found: ${workingDir}`);
+    await reportRunFailed(ctx, runId, "Working directory not found");
+    return;
+  }
+  const tracked = spawnCommandProcess(ctx, event, commandKey);
+  try {
+    await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId,
+      status: "running",
+      pid: tracked.process.pid
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to update run status to running: ${getErrorMessage(err)}`);
+  }
 }
 async function onCommandStop(ctx, event) {
   const runIdStr = event.runId.toString();
-  const tracked = runningProcesses.get(runIdStr);
+  const tracked = processManager.get(runIdStr);
   if (!tracked) {
     console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr} — marking as stopped`);
-    pendingStops.set(runIdStr, Date.now());
+    processManager.markPendingStop(runIdStr);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76197,13 +76633,8 @@ async function onCommandStop(ctx, event) {
     clearTimeout(tracked.softTimeoutTimer);
     tracked.softTimeoutTimer = null;
   }
-  killProcess(tracked.process, "SIGTERM");
-  const exitedAfterSigterm = await waitForExit(runIdStr, SIGTERM_GRACE_PERIOD_MS);
-  if (!exitedAfterSigterm) {
-    console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${runIdStr}`);
-    killProcess(tracked.process, "SIGKILL");
-    await waitForExit(runIdStr, 1000);
-  }
+  tracked.terminationIntent = "stopped";
+  await killTrackedProcess(tracked);
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
       sessionId: ctx.sessionId,
@@ -76216,15 +76647,14 @@ async function onCommandStop(ctx, event) {
   }
 }
 async function shutdownAllCommands(ctx) {
-  if (runningProcesses.size === 0)
+  if (processManager.size === 0)
     return;
-  console.log(`[${formatTimestamp()}] Shutting down ${runningProcesses.size} running command(s)...`);
-  const trackedEntries = [...runningProcesses.entries()];
+  console.log(`[${formatTimestamp()}] Shutting down ${processManager.size} running command(s)...`);
+  const trackedEntries = processManager.getAll();
   for (const [, tracked] of trackedEntries) {
     clearInterval(tracked.flushTimer);
     if (tracked.softTimeoutTimer)
       clearTimeout(tracked.softTimeoutTimer);
-    await flushOutput(ctx, tracked).catch(() => {});
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -76243,23 +76673,22 @@ async function shutdownAllCommands(ctx) {
     t.unref?.();
   });
   for (const [, tracked] of trackedEntries) {
-    if (runningProcesses.has(tracked.runId)) {
+    if (processManager.has(tracked.runId)) {
       killProcess(tracked.process, "SIGKILL");
     }
   }
-  runningProcesses.clear();
-  runningProcessesByCommand.clear();
+  processManager.clear();
+  clearTrackedPids();
   console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, runningProcessesByCommand, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, SOFT_TIMEOUT_MS, SIGTERM_GRACE_PERIOD_MS = 5000;
 var init_command_runner = __esm(() => {
   init_api3();
   init_convex_error();
-  runningProcesses = new Map;
-  runningProcessesByCommand = new Map;
-  pendingStops = new Map;
-  MAX_BUFFER_SIZE = 100 * 1024;
-  SOFT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+  init_orphan_tracker();
+  init_state2();
+  init_manager();
+  init_spawner();
+  init_killer();
 });
 
 // src/commands/machine/daemon-start/handlers/ping.ts
@@ -77228,21 +77657,25 @@ async function recoverState(ctx) {
     console.log(`   ⚠️  Failed to clear stale PIDs: ${getErrorMessage(e)}`);
   }
   try {
-    const runResult = await ctx.deps.backend.mutation(api.commands.clearStaleCommandRuns, {
+    const runResult = await ctx.deps.backend.mutation(api.commands.reapOrphansForDaemonRestart, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     });
-    if (runResult.clearedCount > 0) {
-      console.log(`   \uD83E\uDDF9 Cleared ${runResult.clearedCount} stale command run(s) from backend`);
+    if (runResult.reapedCount > 0) {
+      console.log(`   \uD83E\uDDF9 Reaped ${runResult.reapedCount} command run(s) from previous daemon run (marked as daemon-restart)`);
     }
   } catch (e) {
-    console.log(`   ⚠️  Failed to clear stale command runs: ${getErrorMessage(e)}`);
+    console.warn(`   ⚠️  Failed to reap orphan command runs: ${getErrorMessage(e)}`);
   }
 }
 async function initDaemon() {
   if (!acquireLock()) {
     process.exit(1);
   }
+  const { reaped } = await reapOrphanedProcessGroups();
+  if (reaped > 0) {
+    console.log(`[${formatTimestamp()}] Reaped ${reaped} orphaned process group(s) from previous daemon run`);
+  }
   const convexUrl = getConvexUrl();
   const sessionId = await validateAuthentication(convexUrl);
   const client4 = await getConvexClient();
@@ -77330,6 +77763,7 @@ var init_init2 = __esm(() => {
   init_error_formatting();
   init_version();
   init_pid();
+  init_orphan_tracker();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
@@ -78075,7 +78509,7 @@ function evictStaleDedupEntries(tracker) {
     if (ts < evictBefore)
       tracker.commandStopIds.delete(id3);
   }
-  evictStalePendingStops();
+  processManager.evictStalePendingStops();
 }
 async function dispatchCommandEvent(ctx, event, tracker) {
   const eventId = event._id.toString();
@@ -78331,6 +78765,7 @@ var init_command_loop = __esm(() => {
   init_file_tree_subscription();
   init_git_subscription();
   init_command_runner();
+  init_manager();
   init_init2();
   init_observed_sync();
   init_api3();
@@ -79446,5 +79881,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1151E4B582DED8E964756E2164756E21
+//# debugId=DFA3745A7992596664756E2164756E21
 //# sourceMappingURL=index.js.map