chatroom-cli 1.11.1 → 1.12.0

package/dist/index.js

@@ -10895,10 +10895,10 @@ function initHarnessRegistry() {
 }
 var initialized = false;
 var init_init_registry = __esm(() => {
-  init_registry();
+  init_cursor();
   init_opencode();
   init_pi();
-  init_cursor();
+  init_registry();
 });
 
 // src/infrastructure/services/remote-agents/index.ts
@@ -11134,34 +11134,10 @@ var init_daemon_state = __esm(() => {
   STATE_DIR = join4(CHATROOM_DIR3, "machines", "state");
 });
 
-// src/infrastructure/machine/intentional-stops.ts
-function agentKey2(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
-}
-function markIntentionalStop(chatroomId, role, reason = "user.stop") {
-  pendingStops.set(agentKey2(chatroomId, role), reason);
-}
-function consumeIntentionalStop(chatroomId, role) {
-  const key = agentKey2(chatroomId, role);
-  const reason = pendingStops.get(key) ?? null;
-  if (reason !== null) {
-    pendingStops.delete(key);
-  }
-  return reason;
-}
-function clearIntentionalStop(chatroomId, role) {
-  pendingStops.delete(agentKey2(chatroomId, role));
-}
-var pendingStops;
-var init_intentional_stops = __esm(() => {
-  pendingStops = new Map;
-});
-
 // src/infrastructure/machine/index.ts
 var init_machine = __esm(() => {
   init_storage2();
   init_daemon_state();
-  init_intentional_stops();
 });
 
 // src/commands/auth-status/index.ts
@@ -11709,8 +11685,8 @@ var init_utils = __esm(() => {
 
 // ../../services/backend/prompts/base/shared/getting-started-content.ts
 var init_getting_started_content = __esm(() => {
-  init_utils();
   init_reminder();
+  init_utils();
 });
 
 // ../../services/backend/prompts/cli/index.ts
@@ -12344,8 +12320,7 @@ async function classify(chatroomId, options, deps) {
     console.error(`❌ \`classify\` is only available to the entry point role (${entryPoint}). Your role is ${role}.`);
     console.error("");
     console.error("   Entry point roles receive user messages and must classify them.");
-    console.error("   Other roles receive handoffs and should use:");
-    console.error(`   ${cliEnvPrefix}chatroom task-started --chatroom-id=${chatroomId} --role=${role} --task-id=<task-id> --no-classify`);
+    console.error("   Other roles receive handoffs — use `task read` to mark in_progress.");
     process.exit(1);
   }
   if (originMessageClassification === "new_feature") {
@@ -12839,12 +12814,19 @@ __export(exports_backlog, {
   patchBacklog: () => patchBacklog,
   markForReviewBacklog: () => markForReviewBacklog,
   listBacklog: () => listBacklog,
+  importBacklog: () => importBacklog,
   historyBacklog: () => historyBacklog,
+  exportBacklog: () => exportBacklog,
+  computeContentHash: () => computeContentHash,
   completeBacklog: () => completeBacklog,
+  closeBacklog: () => closeBacklog,
   addBacklog: () => addBacklog
 });
+import { createHash } from "node:crypto";
+import * as nodePath from "node:path";
 async function createDefaultDeps11() {
   const client2 = await getConvexClient();
+  const fs = await import("node:fs/promises");
   return {
     backend: {
       mutation: (endpoint, args) => client2.mutation(endpoint, args),
@@ -12854,6 +12836,11 @@ async function createDefaultDeps11() {
       getSessionId,
       getConvexUrl,
       getOtherSessionUrls
+    },
+    fs: {
+      writeFile: (path2, data) => fs.writeFile(path2, data, "utf-8"),
+      readFile: (path2, encoding) => fs.readFile(path2, { encoding }),
+      mkdir: (path2, options) => fs.mkdir(path2, options)
     }
   };
 }
@@ -12880,17 +12867,19 @@ async function listBacklog(chatroomId, options, deps) {
     const backlogItems = await d.backend.query(api.backlog.listBacklogItems, {
       sessionId,
       chatroomId,
-      statusFilter: "active",
+      statusFilter: "backlog",
+      sort: options.sort,
+      filter: options.filter,
       limit
     });
     console.log("");
     console.log("══════════════════════════════════════════════════");
-    console.log("\uD83D\uDCCB ACTIVE BACKLOG");
+    console.log("\uD83D\uDCCB BACKLOG");
     console.log("══════════════════════════════════════════════════");
     console.log(`Chatroom: ${chatroomId}`);
     console.log("");
     if (backlogItems.length === 0) {
-      console.log("No active backlog items.");
+      console.log("No backlog items.");
     } else {
       console.log("──────────────────────────────────────────────────");
       for (let i2 = 0;i2 < backlogItems.length; i2++) {
@@ -13173,7 +13162,7 @@ async function historyBacklog(chatroomId, options, deps) {
   const sessionId = requireAuth2(d);
   validateChatroomId(chatroomId);
   const now = Date.now();
-  const defaultFrom = now - 30 * 24 * 60 * 60 * 1000;
+  const defaultFrom = now - 2592000000;
   let fromMs;
   let toMs;
   if (options.from) {
@@ -13263,6 +13252,38 @@ async function historyBacklog(chatroomId, options, deps) {
     return;
   }
 }
+async function closeBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps11();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
+  if (!options.backlogItemId || options.backlogItemId.trim().length === 0) {
+    console.error(`❌ Backlog item ID is required`);
+    process.exit(1);
+    return;
+  }
+  if (!options.reason || options.reason.trim().length === 0) {
+    console.error(`❌ Reason is required when closing a backlog item`);
+    process.exit(1);
+    return;
+  }
+  try {
+    await d.backend.mutation(api.backlog.closeBacklogItem, {
+      sessionId,
+      itemId: options.backlogItemId,
+      reason: options.reason
+    });
+    console.log("");
+    console.log("✅ Backlog item closed");
+    console.log(`   ID: ${options.backlogItemId}`);
+    console.log(`   Status: closed`);
+    console.log(`   Reason: ${options.reason}`);
+    console.log("");
+  } catch (error) {
+    console.error(`❌ Failed to close backlog item: ${error.message}`);
+    process.exit(1);
+    return;
+  }
+}
 function getStatusEmoji(status) {
   switch (status) {
     case "pending":
@@ -13283,10 +13304,121 @@ function getStatusEmoji(status) {
       return "⚫";
   }
 }
+function computeContentHash(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+async function exportBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps11();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
+  if (!d.fs) {
+    console.error("❌ File system operations not available");
+    process.exit(1);
+    return;
+  }
+  try {
+    const backlogItems = await d.backend.query(api.backlog.listBacklogItems, {
+      sessionId,
+      chatroomId,
+      statusFilter: "backlog"
+    });
+    const exportData = {
+      exportedAt: Date.now(),
+      chatroomId,
+      items: backlogItems.map((item) => {
+        const exportItem = {
+          contentHash: computeContentHash(item.content),
+          content: item.content,
+          status: item.status,
+          createdBy: item.createdBy ?? "unknown",
+          createdAt: item.createdAt
+        };
+        if (item.complexity)
+          exportItem.complexity = item.complexity;
+        if (item.value)
+          exportItem.value = item.value;
+        if (item.priority !== undefined)
+          exportItem.priority = item.priority;
+        return exportItem;
+      })
+    };
+    const exportDir = options.path ?? nodePath.join(process.cwd(), DEFAULT_EXPORT_DIR);
+    await d.fs.mkdir(exportDir, { recursive: true });
+    const filePath = nodePath.join(exportDir, BACKLOG_EXPORT_FILENAME);
+    await d.fs.writeFile(filePath, JSON.stringify(exportData, null, 2));
+    console.log("");
+    console.log(`✅ Exported ${exportData.items.length} backlog item(s)`);
+    console.log(`   File: ${filePath}`);
+    console.log("");
+  } catch (error) {
+    console.error(`❌ Failed to export backlog items: ${error.message}`);
+    process.exit(1);
+    return;
+  }
+}
+async function importBacklog(chatroomId, options, deps) {
+  const d = deps ?? await createDefaultDeps11();
+  const sessionId = requireAuth2(d);
+  validateChatroomId(chatroomId);
+  if (!d.fs) {
+    console.error("❌ File system operations not available");
+    process.exit(1);
+    return;
+  }
+  try {
+    const importDir = options.path ?? nodePath.join(process.cwd(), DEFAULT_EXPORT_DIR);
+    const filePath = nodePath.join(importDir, BACKLOG_EXPORT_FILENAME);
+    const raw = await d.fs.readFile(filePath, "utf-8");
+    const exportData = JSON.parse(raw);
+    const ageMs = Date.now() - exportData.exportedAt;
+    if (ageMs > STALENESS_THRESHOLD_MS) {
+      const ageDays = Math.floor(ageMs / 86400000);
+      console.log(`⚠️  This export is ${ageDays} days old and may be stale.`);
+    }
+    const existingItems = await d.backend.query(api.backlog.listBacklogItems, {
+      sessionId,
+      chatroomId,
+      statusFilter: "backlog"
+    });
+    const existingHashes = new Set(existingItems.map((item) => computeContentHash(item.content)));
+    let imported = 0;
+    let skipped = 0;
+    for (const item of exportData.items) {
+      const hash = computeContentHash(item.content);
+      if (existingHashes.has(hash)) {
+        skipped++;
+        continue;
+      }
+      await d.backend.mutation(api.backlog.createBacklogItem, {
+        sessionId,
+        chatroomId,
+        content: item.content,
+        createdBy: item.createdBy,
+        priority: item.priority,
+        complexity: item.complexity,
+        value: item.value
+      });
+      existingHashes.add(hash);
+      imported++;
+    }
+    console.log("");
+    console.log(`✅ Import complete`);
+    console.log(`   Total items in file: ${exportData.items.length}`);
+    console.log(`   Imported: ${imported}`);
+    console.log(`   Skipped (duplicate): ${skipped}`);
+    console.log("");
+  } catch (error) {
+    console.error(`❌ Failed to import backlog items: ${error.message}`);
+    process.exit(1);
+    return;
+  }
+}
+var BACKLOG_EXPORT_FILENAME = "backlog-export.json", STALENESS_THRESHOLD_MS, DEFAULT_EXPORT_DIR = ".chatroom/exports";
 var init_backlog = __esm(() => {
   init_api3();
   init_storage();
   init_client2();
+  STALENESS_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000;
 });
 
 // src/utils/file-content.ts
@@ -13378,6 +13510,32 @@ async function taskRead(chatroomId, options, deps) {
     console.log(`✅ Task content:`);
     console.log(`   Task ID: ${result.taskId}`);
     console.log(`   Status: ${result.status}`);
+    if (result.context) {
+      console.log("");
+      console.log("PINNED CONTEXT");
+      console.log("---");
+      console.log("<context>");
+      console.log(result.context.content);
+      console.log("</context>");
+      if (result.context.triggerMessageContent) {
+        console.log("in response to");
+        const senderTag = result.context.triggerMessageSenderRole ?? "unknown";
+        console.log(`<${senderTag}-message>`);
+        console.log(result.context.triggerMessageContent);
+        console.log(`</${senderTag}-message>`);
+      }
+      const hoursAgo = Math.round(result.context.elapsedHours);
+      const msgsSince = result.context.messagesSinceContext;
+      const isStale = hoursAgo >= 24 || msgsSince >= 50;
+      if (isStale) {
+        const ageLabel = hoursAgo >= 48 ? `${Math.round(hoursAgo / 24)}d old` : hoursAgo >= 24 ? `${hoursAgo}h old` : `${msgsSince} messages old`;
+        console.log(`<system-notice>`);
+        console.log(`⚠️ Context is ${ageLabel}.`);
+        console.log(`   Entry point role will update when needed.`);
+        console.log(`</system-notice>`);
+      }
+      console.log("---");
+    }
     console.log(`
 ${result.content}`);
   } catch (error) {
@@ -14280,310 +14438,98 @@ var init_get_system_prompt = __esm(() => {
 // ../../services/backend/config/reliability.ts
 var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000;
 
-// src/commands/machine/daemon-start/utils.ts
-function formatTimestamp() {
-  return new Date().toISOString().replace("T", " ").substring(0, 19);
-}
-
-// src/events/lifecycle/on-agent-shutdown.ts
-async function onAgentShutdown(ctx, options) {
-  const { chatroomId, role, pid, skipKill } = options;
-  try {
-    ctx.deps.stops.mark(chatroomId, role, options.stopReason ?? "user.stop");
-  } catch (e) {
-    console.log(`   ⚠️  Failed to mark intentional stop for ${role}: ${e.message}`);
-  }
-  let killed = false;
-  if (!skipKill) {
-    try {
-      ctx.deps.processes.kill(-pid, "SIGTERM");
-    } catch (e) {
-      const isEsrch = e.code === "ESRCH" || e.message?.includes("ESRCH");
-      if (isEsrch) {
-        killed = true;
-      }
-      if (!isEsrch) {
-        console.log(`   ⚠️  Failed to send SIGTERM to ${role}: ${e.message}`);
-      }
-    }
-    if (!killed) {
-      const SIGTERM_TIMEOUT_MS = 1e4;
-      const POLL_INTERVAL_MS2 = 500;
-      const deadline = Date.now() + SIGTERM_TIMEOUT_MS;
-      while (Date.now() < deadline) {
-        await ctx.deps.clock.delay(POLL_INTERVAL_MS2);
-        try {
-          ctx.deps.processes.kill(pid, 0);
-        } catch {
-          killed = true;
-          break;
-        }
-      }
-    }
-    if (!killed) {
-      try {
-        ctx.deps.processes.kill(-pid, "SIGKILL");
-      } catch {
-        killed = true;
-      }
-    }
-    if (!killed) {
-      await ctx.deps.clock.delay(5000);
-      try {
-        ctx.deps.processes.kill(pid, 0);
-        console.log(`   ⚠️  Process ${pid} (${role}) still alive after SIGKILL — possible zombie`);
-      } catch {
-        killed = true;
-      }
-    }
-  }
-  if (killed || skipKill) {
-    try {
-      ctx.deps.machine.clearAgentPid(ctx.machineId, chatroomId, role);
-    } catch (e) {
-      console.log(`   ⚠️  Failed to clear local PID for ${role}: ${e.message}`);
-    }
-  }
-  return {
-    killed: killed || (skipKill ?? false),
-    cleaned: killed || (skipKill ?? false)
-  };
-}
-
-// src/events/lifecycle/on-daemon-shutdown.ts
-async function onDaemonShutdown(ctx) {
-  const agents = ctx.deps.machine.listAgentEntries(ctx.machineId);
-  if (agents.length > 0) {
-    console.log(`[${formatTimestamp()}] Stopping ${agents.length} agent(s)...`);
-    await Promise.allSettled(agents.map(async ({ chatroomId, role, entry }) => {
-      const result = await onAgentShutdown(ctx, {
-        chatroomId,
-        role,
-        pid: entry.pid
-      });
-      if (result.killed) {
-        console.log(`   Sent SIGTERM to ${role} (PID ${entry.pid})`);
-      } else {
-        console.log(`   ${role} (PID ${entry.pid}) already exited`);
-      }
-      return result;
-    }));
-    await ctx.deps.clock.delay(AGENT_SHUTDOWN_TIMEOUT_MS);
-    for (const { role, entry } of agents) {
-      try {
-        ctx.deps.processes.kill(entry.pid, 0);
-        ctx.deps.processes.kill(entry.pid, "SIGKILL");
-        console.log(`   Force-killed ${role} (PID ${entry.pid})`);
-      } catch {}
-    }
-    console.log(`[${formatTimestamp()}] All agents stopped`);
+// src/events/daemon/agent/on-request-start-agent.ts
+async function onRequestStartAgent(ctx, event) {
+  const eventId = event._id.toString();
+  if (Date.now() > event.deadline) {
+    console.log(`[daemon] ⏰ Skipping expired agent.requestStart for role=${event.role} (id: ${eventId}, deadline passed)`);
+    return;
   }
-  try {
-    await ctx.deps.backend.mutation(api.machines.updateDaemonStatus, {
+  console.log(`[daemon] Processing agent.requestStart (id: ${eventId})`);
+  const result = await ctx.deps.agentProcessManager.ensureRunning({
+    chatroomId: event.chatroomId,
+    role: event.role,
+    agentHarness: event.agentHarness,
+    model: event.model,
+    workingDir: event.workingDir,
+    reason: event.reason
+  });
+  if (!result.success) {
+    console.log(`[daemon] Agent start rejected for role=${event.role}: ${result.error ?? "unknown"}`);
+  } else {
+    ctx.deps.backend.mutation(api.workspaces.registerWorkspace, {
       sessionId: ctx.sessionId,
+      chatroomId: event.chatroomId,
       machineId: ctx.machineId,
-      connected: false
+      workingDir: event.workingDir,
+      hostname: ctx.config?.hostname ?? "unknown",
+      registeredBy: event.role
+    }).catch((err) => {
+      console.warn(`[daemon] ⚠️ Failed to register workspace: ${err.message}`);
     });
-  } catch {}
+  }
 }
-var AGENT_SHUTDOWN_TIMEOUT_MS = 5000;
-var init_on_daemon_shutdown = __esm(() => {
+var init_on_request_start_agent = __esm(() => {
   init_api3();
 });
 
-// src/commands/machine/daemon-start/handlers/shared.ts
-async function clearAgentPidEverywhere(ctx, chatroomId, role) {
-  try {
-    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-      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);
+// src/commands/machine/daemon-start/handlers/stop-agent.ts
+async function executeStopAgent(ctx, args) {
+  const { chatroomId, role, reason } = args;
+  console.log(`   ↪ stop-agent command received`);
+  console.log(`      Chatroom: ${chatroomId}`);
+  console.log(`      Role: ${role}`);
+  console.log(`      Reason: ${reason}`);
+  const result = await ctx.deps.agentProcessManager.stop({
+    chatroomId,
+    role,
+    reason
+  });
+  const msg = result.success ? `Agent stopped (${role})` : `Failed to stop agent (${role})`;
+  console.log(`   ${result.success ? "✅" : "⚠️ "} ${msg}`);
+  return { result: msg, failed: !result.success };
 }
-var init_shared = __esm(() => {
-  init_api3();
-});
 
-// 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`);
-  } else {
-    let recovered = 0;
-    let cleared = 0;
-    const chatroomIds = new Set;
-    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++;
-        chatroomIds.add(chatroomId);
-      } 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`);
-    for (const chatroomId of chatroomIds) {
-      try {
-        const configsResult = await ctx.deps.backend.query(api.machines.getMachineAgentConfigs, {
-          sessionId: ctx.sessionId,
-          chatroomId
-        });
-        for (const config3 of configsResult.configs) {
-          if (config3.machineId === ctx.machineId && config3.workingDir) {
-            ctx.activeWorkingDirs.add(config3.workingDir);
-          }
-        }
-      } catch {}
-    }
-    if (ctx.activeWorkingDirs.size > 0) {
-      console.log(`   \uD83D\uDD00 Recovered ${ctx.activeWorkingDirs.size} active working dir(s) for git tracking`);
-    }
+// src/events/daemon/agent/on-request-stop-agent.ts
+async function onRequestStopAgent(ctx, event) {
+  if (Date.now() > event.deadline) {
+    console.log(`[daemon] ⏰ Skipping expired agent.requestStop for role=${event.role} (deadline passed)`);
+    return;
   }
+  await executeStopAgent(ctx, {
+    chatroomId: event.chatroomId,
+    role: event.role,
+    reason: event.reason
+  });
 }
-var init_state_recovery = __esm(() => {
-  init_api3();
-  init_shared();
-});
+var init_on_request_stop_agent = () => {};
 
-// src/infrastructure/services/harness-spawning/rate-limiter.ts
-class SpawnRateLimiter {
-  config;
-  buckets = new Map;
-  constructor(config3 = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config3 };
+// src/commands/machine/pid.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+function getUrlHash() {
+  const url = getConvexUrl();
+  return createHash2("sha256").update(url).digest("hex").substring(0, 8);
+}
+function getPidFileName() {
+  return `daemon-${getUrlHash()}.pid`;
+}
+function ensureChatroomDir() {
+  if (!existsSync4(CHATROOM_DIR4)) {
+    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
-  tryConsume(chatroomId, reason) {
-    if (reason.startsWith("user.")) {
-      return { allowed: true };
-    }
-    const bucket = this._getOrCreateBucket(chatroomId);
-    this._refill(bucket);
-    if (bucket.tokens < 1) {
-      const elapsed = Date.now() - bucket.lastRefillAt;
-      const retryAfterMs = this.config.refillRateMs - elapsed;
-      console.warn(`⚠️ [RateLimiter] Agent spawn rate-limited for chatroom ${chatroomId} (reason: ${reason}). Retry after ${retryAfterMs}ms`);
-      return { allowed: false, retryAfterMs };
-    }
-    bucket.tokens -= 1;
-    const remaining = Math.floor(bucket.tokens);
-    if (remaining <= LOW_TOKEN_THRESHOLD) {
-      console.warn(`⚠️ [RateLimiter] Agent spawn tokens running low for chatroom ${chatroomId} (${remaining}/${this.config.maxTokens} remaining)`);
-    }
-    return { allowed: true };
-  }
-  getStatus(chatroomId) {
-    const bucket = this._getOrCreateBucket(chatroomId);
-    this._refill(bucket);
-    return {
-      remaining: Math.floor(bucket.tokens),
-      total: this.config.maxTokens
-    };
-  }
-  _getOrCreateBucket(chatroomId) {
-    if (!this.buckets.has(chatroomId)) {
-      this.buckets.set(chatroomId, {
-        tokens: this.config.initialTokens,
-        lastRefillAt: Date.now()
-      });
-    }
-    return this.buckets.get(chatroomId);
-  }
-  _refill(bucket) {
-    const now = Date.now();
-    const elapsed = now - bucket.lastRefillAt;
-    if (elapsed >= this.config.refillRateMs) {
-      const tokensToAdd = Math.floor(elapsed / this.config.refillRateMs);
-      bucket.tokens = Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
-      bucket.lastRefillAt += tokensToAdd * this.config.refillRateMs;
-    }
-  }
-}
-var DEFAULT_CONFIG, LOW_TOKEN_THRESHOLD = 1;
-var init_rate_limiter = __esm(() => {
-  DEFAULT_CONFIG = {
-    maxTokens: 5,
-    refillRateMs: 60000,
-    initialTokens: 5
-  };
-});
-
-// src/infrastructure/services/harness-spawning/harness-spawning-service.ts
-class HarnessSpawningService {
-  rateLimiter;
-  concurrentAgents = new Map;
-  constructor({ rateLimiter }) {
-    this.rateLimiter = rateLimiter;
-  }
-  shouldAllowSpawn(chatroomId, reason) {
-    const current = this.concurrentAgents.get(chatroomId) ?? 0;
-    if (current >= MAX_CONCURRENT_AGENTS_PER_CHATROOM) {
-      console.warn(`⚠️ [HarnessSpawningService] Concurrent agent limit reached for chatroom ${chatroomId} ` + `(${current}/${MAX_CONCURRENT_AGENTS_PER_CHATROOM} active agents). Spawn rejected.`);
-      return { allowed: false };
-    }
-    const result = this.rateLimiter.tryConsume(chatroomId, reason);
-    if (!result.allowed) {
-      console.warn(`⚠️ [HarnessSpawningService] Spawn blocked by rate limiter for chatroom ${chatroomId} ` + `(reason: ${reason}).`);
-    }
-    return result;
-  }
-  recordSpawn(chatroomId) {
-    const current = this.concurrentAgents.get(chatroomId) ?? 0;
-    this.concurrentAgents.set(chatroomId, current + 1);
-  }
-  recordExit(chatroomId) {
-    const current = this.concurrentAgents.get(chatroomId) ?? 0;
-    const next = Math.max(0, current - 1);
-    this.concurrentAgents.set(chatroomId, next);
-  }
-  getConcurrentCount(chatroomId) {
-    return this.concurrentAgents.get(chatroomId) ?? 0;
-  }
-}
-var MAX_CONCURRENT_AGENTS_PER_CHATROOM = 10;
-
-// src/infrastructure/services/harness-spawning/index.ts
-var init_harness_spawning = __esm(() => {
-  init_rate_limiter();
-});
-
-// src/commands/machine/pid.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
-function getUrlHash() {
-  const url = getConvexUrl();
-  return createHash("sha256").update(url).digest("hex").substring(0, 8);
-}
-function getPidFileName() {
-  return `daemon-${getUrlHash()}.pid`;
-}
-function ensureChatroomDir() {
-  if (!existsSync4(CHATROOM_DIR4)) {
-    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
-  }
-}
-function getPidFilePath() {
-  return join5(CHATROOM_DIR4, getPidFileName());
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+}
+function getPidFilePath() {
+  return join6(CHATROOM_DIR4, getPidFileName());
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
 }
 function readPid() {
@@ -14641,852 +14587,566 @@ function releaseLock() {
 var CHATROOM_DIR4;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join5(homedir4(), ".chatroom");
+  CHATROOM_DIR4 = join6(homedir4(), ".chatroom");
 });
 
-// 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/utils.ts
+function formatTimestamp() {
+  return new Date().toISOString().replace("T", " ").substring(0, 19);
 }
 
-// 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})`);
-  }
-  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);
-  }
+// src/infrastructure/git/types.ts
+function makeGitStateKey(machineId, workingDir) {
+  return `${machineId}::${workingDir}`;
 }
-var init_on_agent_exited = __esm(() => {
-  init_api3();
-});
+var FULL_DIFF_MAX_BYTES = 500000, COMMITS_PER_PAGE = 20;
 
-// 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})`);
+// src/infrastructure/git/git-reader.ts
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+async function runGit(args, cwd) {
+  try {
+    const result = await execAsync2(`git ${args}`, {
+      cwd,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_PAGER: "cat", NO_COLOR: "1" },
+      maxBuffer: FULL_DIFF_MAX_BYTES + 64 * 1024
+    });
+    return result;
+  } catch (err) {
+    return { error: err };
+  }
 }
-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})`);
+function isGitNotInstalled(message) {
+  return message.includes("command not found") || message.includes("ENOENT") || message.includes("not found") || message.includes("'git' is not recognized");
 }
-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();
-    }
-  };
+function isNotAGitRepo(message) {
+  return message.includes("not a git repository") || message.includes("Not a git repository");
 }
-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] = [];
-      }
+function isPermissionDenied(message) {
+  return message.includes("Permission denied") || message.includes("EACCES");
+}
+function isEmptyRepo(stderr) {
+  return stderr.includes("does not have any commits yet") || stderr.includes("no commits yet") || stderr.includes("ambiguous argument 'HEAD'") || stderr.includes("unknown revision or path");
+}
+function classifyError(errMessage) {
+  if (isGitNotInstalled(errMessage)) {
+    return { status: "error", message: "git is not installed or not in PATH" };
+  }
+  if (isNotAGitRepo(errMessage)) {
+    return { status: "not_found" };
+  }
+  if (isPermissionDenied(errMessage)) {
+    return { status: "error", message: `Permission denied: ${errMessage}` };
+  }
+  return { status: "error", message: errMessage.trim() };
+}
+async function isGitRepo(workingDir) {
+  const result = await runGit("rev-parse --git-dir", workingDir);
+  if ("error" in result)
+    return false;
+  return result.stdout.trim().length > 0;
+}
+async function getBranch(workingDir) {
+  const result = await runGit("rev-parse --abbrev-ref HEAD", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (errMsg.includes("unknown revision") || errMsg.includes("No such file or directory") || errMsg.includes("does not have any commits")) {
+      return { status: "available", branch: "HEAD" };
     }
+    return classifyError(errMsg);
   }
-  return results;
+  const branch = result.stdout.trim();
+  if (!branch) {
+    return { status: "error", message: "git rev-parse returned empty output" };
+  }
+  return { status: "available", branch };
 }
-function createDefaultDeps19() {
+async function isDirty(workingDir) {
+  const result = await runGit("status --porcelain", workingDir);
+  if ("error" in result)
+    return false;
+  return result.stdout.trim().length > 0;
+}
+function parseDiffStatLine(statLine) {
+  const filesMatch = statLine.match(/(\d+)\s+file/);
+  const insertMatch = statLine.match(/(\d+)\s+insertion/);
+  const deleteMatch = statLine.match(/(\d+)\s+deletion/);
   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))
-    },
-    spawning: new HarnessSpawningService({ rateLimiter: new SpawnRateLimiter })
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
+    deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0
   };
 }
-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}`);
-      }
+async function getDiffStat(workingDir) {
+  const result = await runGit("diff HEAD --stat", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (isEmptyRepo(result.error.message)) {
+      return { status: "no_commits" };
     }
-    console.error(`
-Run: chatroom auth login`);
-    releaseLock();
-    process.exit(1);
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    return classified;
   }
-  return sessionId;
+  const output = result.stdout;
+  const stderr = result.stderr;
+  if (isEmptyRepo(stderr)) {
+    return { status: "no_commits" };
+  }
+  if (!output.trim()) {
+    return {
+      status: "available",
+      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
+    };
+  }
+  const lines = output.trim().split(`
+`);
+  const summaryLine = lines[lines.length - 1] ?? "";
+  const diffStat = parseDiffStatLine(summaryLine);
+  return { status: "available", diffStat };
 }
-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);
+async function getFullDiff(workingDir) {
+  const result = await runGit("diff HEAD", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (isEmptyRepo(errMsg)) {
+      return { status: "no_commits" };
+    }
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    return classified;
+  }
+  const stderr = result.stderr;
+  if (isEmptyRepo(stderr)) {
+    return { status: "no_commits" };
+  }
+  const raw = result.stdout;
+  const byteLength2 = Buffer.byteLength(raw, "utf8");
+  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
+    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
+    return { status: "truncated", content: truncated, truncated: true };
   }
+  return { status: "available", content: raw, truncated: false };
 }
-function setupMachine() {
-  ensureMachineRegistered();
-  const config3 = loadMachineConfig();
-  return config3;
+async function getRecentCommits(workingDir, count = 20, skip = 0) {
+  const format = "%H%x00%h%x00%s%x00%an%x00%aI";
+  const skipArg = skip > 0 ? ` --skip=${skip}` : "";
+  const result = await runGit(`log -${count}${skipArg} --format=${format}`, workingDir);
+  if ("error" in result) {
+    return [];
+  }
+  const output = result.stdout.trim();
+  if (!output)
+    return [];
+  const commits = [];
+  for (const line of output.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const parts = trimmed.split("\x00");
+    if (parts.length !== 5)
+      continue;
+    const [sha, shortSha, message, author, date] = parts;
+    commits.push({ sha, shortSha, message, author, date });
+  }
+  return commits;
 }
-async function registerCapabilities(client2, sessionId, config3, agentServices) {
-  const { machineId } = config3;
-  const availableModels = await discoverModels(agentServices);
-  try {
-    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}`);
+async function getCommitDetail(workingDir, sha) {
+  const result = await runGit(`show ${sha} --format="" --stat -p`, workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    if (isEmptyRepo(errMsg) || errMsg.includes("unknown revision") || errMsg.includes("bad object") || errMsg.includes("does not exist")) {
+      return { status: "not_found" };
+    }
+    return classified;
   }
-  return availableModels;
+  const raw = result.stdout;
+  const byteLength2 = Buffer.byteLength(raw, "utf8");
+  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
+    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
+    return { status: "truncated", content: truncated, truncated: true };
+  }
+  return { status: "available", content: raw, truncated: false };
 }
-async function connectDaemon(client2, sessionId, machineId, convexUrl) {
+async function getCommitMetadata(workingDir, sha) {
+  const format = "%s%x00%an%x00%aI";
+  const result = await runGit(`log -1 --format=${format} ${sha}`, workingDir);
+  if ("error" in result)
+    return null;
+  const output = result.stdout.trim();
+  if (!output)
+    return null;
+  const parts = output.split("\x00");
+  if (parts.length !== 3)
+    return null;
+  return { message: parts[0], author: parts[1], date: parts[2] };
+}
+async function runCommand(command, cwd) {
   try {
-    await client2.mutation(api.machines.updateDaemonStatus, {
-      sessionId,
-      machineId,
-      connected: true
+    const result = await execAsync2(command, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+      timeout: 15000
     });
-  } catch (error) {
-    if (isNetworkError(error)) {
-      formatConnectivityError(error, convexUrl);
-    } else {
-      console.error(`❌ Failed to update daemon status: ${error.message}`);
-    }
-    releaseLock();
-    process.exit(1);
+    return result;
+  } catch (err) {
+    return { error: err };
   }
 }
-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}`);
+function parseRepoSlug(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  const httpsMatch = trimmed.match(/https?:\/\/[^/]+\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (httpsMatch && httpsMatch[1] && httpsMatch[2]) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  const sshMatch = trimmed.match(/git@[^:]+:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch && sshMatch[1] && sshMatch[2]) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  return null;
 }
-async function recoverState(ctx) {
-  console.log(`
-[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
+async function getOriginRepoSlug(cwd) {
+  const result = await runGit("remote get-url origin", cwd);
+  if ("error" in result)
+    return null;
+  const url = result.stdout.trim();
+  if (!url)
+    return null;
+  return parseRepoSlug(url);
+}
+async function getOpenPRsForBranch(cwd, branch) {
+  const repoSlug = await getOriginRepoSlug(cwd);
+  const repoFlag = repoSlug ? ` --repo ${JSON.stringify(repoSlug)}` : "";
+  const result = await runCommand(`gh pr list --head ${JSON.stringify(branch)} --state open --json number,title,url,headRefName,state --limit 5${repoFlag}`, cwd);
+  if ("error" in result) {
+    return [];
+  }
+  const output = result.stdout.trim();
+  if (!output)
+    return [];
   try {
-    await recoverAgentState(ctx);
-  } catch (e) {
-    console.log(`   ⚠️  Recovery failed: ${e.message}`);
-    console.log(`   Continuing with fresh state`);
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.number === "number" && typeof item.title === "string" && typeof item.url === "string" && typeof item.headRefName === "string" && typeof item.state === "string").map((item) => ({
+      number: item.number,
+      title: item.title,
+      url: item.url,
+      headRefName: item.headRefName,
+      state: item.state
+    }));
+  } catch {
+    return [];
   }
 }
-async function initDaemon() {
-  if (!acquireLock()) {
-    process.exit(1);
+var execAsync2;
+var init_git_reader = __esm(() => {
+  execAsync2 = promisify2(exec2);
+});
+
+// src/commands/machine/daemon-start/git-subscription.ts
+function startGitRequestSubscription(ctx, wsClient2) {
+  const processedRequestIds = new Map;
+  const DEDUP_TTL_MS = 5 * 60 * 1000;
+  let processing = false;
+  const unsubscribe = wsClient2.onUpdate(api.workspaces.getPendingRequests, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  }, (requests) => {
+    if (!requests || requests.length === 0)
+      return;
+    if (processing)
+      return;
+    processing = true;
+    processRequests(ctx, requests, processedRequestIds, DEDUP_TTL_MS).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️  Git request processing failed: ${err.message}`);
+    }).finally(() => {
+      processing = false;
+    });
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️  Git request subscription error: ${err.message}`);
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git request subscription started (reactive)`);
+  return {
+    stop: () => {
+      unsubscribe();
+      console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git request subscription stopped`);
+    }
+  };
+}
+function extractDiffStatFromShowOutput(content) {
+  for (const line of content.split(`
+`)) {
+    if (/\d+\s+file.*changed/.test(line)) {
+      return parseDiffStatLine(line);
+    }
   }
-  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 = createDefaultDeps19();
-  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,
-    activeWorkingDirs: new Set,
-    lastPushedGitState: new Map,
-    agentEndedTurn: new Map
-  };
-  registerEventListeners(ctx);
-  logStartup(ctx, availableModels);
-  await recoverState(ctx);
-  return ctx;
-}
-var init_init2 = __esm(() => {
-  init_state_recovery();
-  init_api3();
-  init_storage();
-  init_client2();
-  init_machine();
-  init_intentional_stops();
-  init_remote_agents();
-  init_harness_spawning();
-  init_error_formatting();
-  init_version();
-  init_pid();
-  init_register_listeners();
-});
-
-// 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";
+  return { filesChanged: 0, insertions: 0, deletions: 0 };
 }
-
-// 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.getMachineAgentConfigs, {
+async function processFullDiff(ctx, req) {
+  const result = await getFullDiff(req.workingDir);
+  if (result.status === "available" || result.status === "truncated") {
+    const diffStatResult = await getDiffStat(req.workingDir);
+    const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
       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}`);
-  }
-  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 }
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      diffContent: result.content,
+      truncated: result.truncated,
+      diffStat
     });
-  } 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}`);
-  const agentEndKey = `${chatroomId}:${role.toLowerCase()}`;
-  ctx.agentEndedTurn.delete(agentEndKey);
-  ctx.deps.spawning.recordSpawn(chatroomId);
-  try {
-    await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed: ${req.workingDir} (${diffStat.filesChanged} files, ${result.truncated ? "truncated" : "complete"})`);
+  } else {
+    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
-      chatroomId,
-      role,
-      pid,
-      model,
-      reason
-    });
-    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
-  });
-  ctx.activeWorkingDirs.add(workingDir);
-  spawnResult.onExit(({ code: code2, signal }) => {
-    ctx.deps.spawning.recordExit(chatroomId);
-    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(() => {
-      ctx.agentEndedTurn.set(agentEndKey, true);
-      try {
-        ctx.deps.processes.kill(-pid, "SIGTERM");
-      } catch {}
+      workingDir: req.workingDir,
+      diffContent: "",
+      truncated: false,
+      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
     });
+    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed (empty): ${req.workingDir} (${result.status})`);
   }
-  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)`);
+async function processCommitDetail(ctx, req) {
+  if (!req.sha) {
+    throw new Error("commit_detail request missing sha");
+  }
+  const [result, metadata] = await Promise.all([
+    getCommitDetail(req.workingDir, req.sha),
+    getCommitMetadata(req.workingDir, req.sha)
+  ]);
+  if (result.status === "not_found") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      sha: req.sha,
+      status: "not_found",
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
     return;
   }
-  const spawnCheck = ctx.deps.spawning.shouldAllowSpawn(event.chatroomId, event.reason);
-  if (!spawnCheck.allowed) {
-    const retryMsg = spawnCheck.retryAfterMs ? ` Retry after ${spawnCheck.retryAfterMs}ms.` : "";
-    console.warn(`[daemon] ⚠️  Spawn suppressed for chatroom=${event.chatroomId} role=${event.role} reason=${event.reason}.${retryMsg}`);
+  if (result.status === "error") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      sha: req.sha,
+      status: "error",
+      errorMessage: result.message,
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
     return;
   }
-  await executeStartAgent(ctx, {
-    chatroomId: event.chatroomId,
-    role: event.role,
-    agentHarness: event.agentHarness,
-    model: event.model,
-    workingDir: event.workingDir,
-    reason: event.reason
+  const diffStat = extractDiffStatFromShowOutput(result.content);
+  await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    sha: req.sha,
+    status: "available",
+    diffContent: result.content,
+    truncated: result.truncated,
+    message: metadata?.message,
+    author: metadata?.author,
+    date: metadata?.date,
+    diffStat
   });
+  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Commit detail pushed: ${req.sha.slice(0, 7)} in ${req.workingDir}`);
 }
-var init_on_request_start_agent = __esm(() => {
-  init_start_agent();
-});
-
-// 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, {
+async function processMoreCommits(ctx, req) {
+  const offset = req.offset ?? 0;
+  const commits = await getRecentCommits(req.workingDir, COMMITS_PER_PAGE, offset);
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  await ctx.deps.backend.mutation(api.workspaces.appendMoreCommits, {
     sessionId: ctx.sessionId,
-    chatroomId
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    commits,
+    hasMoreCommits
   });
-  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 {}
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC More commits appended: ${req.workingDir} (+${commits.length} commits, offset=${offset})`);
+}
+async function processRequests(ctx, requests, processedRequestIds, dedupTtlMs) {
+  const evictBefore = Date.now() - dedupTtlMs;
+  for (const [id, ts] of processedRequestIds) {
+    if (ts < evictBefore)
+      processedRequestIds.delete(id);
+  }
+  for (const req of requests) {
+    const requestId = req._id.toString();
+    if (processedRequestIds.has(requestId))
       continue;
-    }
+    processedRequestIds.set(requestId, Date.now());
     try {
-      const shutdownResult = await onAgentShutdown(ctx, {
-        chatroomId,
-        role,
-        pid,
-        stopReason
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "processing"
       });
-      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;
+      switch (req.requestType) {
+        case "full_diff":
+          await processFullDiff(ctx, req);
+          break;
+        case "commit_detail":
+          await processCommitDetail(ctx, req);
+          break;
+        case "more_commits":
+          await processMoreCommits(ctx, req);
+          break;
       }
-    } catch (e) {
-      lastError = e;
-      console.log(`   ⚠️  Failed to stop agent (PID: ${pid}): ${e.message}`);
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "done"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Failed to process ${req.requestType} request: ${err.message}`);
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "error"
+      }).catch(() => {});
     }
   }
-  if (lastError && !anyKilled) {
-    const msg = `Failed to stop agent: ${lastError.message}`;
-    console.log(`   ⚠️  ${msg}`);
-    return { result: msg, failed: true };
-  }
-  if (!anyKilled) {
-    return {
-      result: `All recorded PIDs appear stale (processes not found or belong to different programs)`,
-      failed: true
-    };
-  }
-  const killedCount = allPids.length > 1 ? ` (${allPids.length} PIDs)` : ``;
-  return { result: `Agent stopped${killedCount}`, failed: false };
 }
-var init_stop_agent = __esm(() => {
+var init_git_subscription = __esm(() => {
   init_api3();
-  init_shared();
+  init_git_reader();
 });
 
-// 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/git-heartbeat.ts
+import { createHash as createHash3 } from "node:crypto";
+async function pushGitState(ctx) {
+  let workspaces;
+  try {
+    workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces for git sync: ${err.message}`);
     return;
   }
-  await executeStopAgent(ctx, {
-    chatroomId: event.chatroomId,
-    role: event.role,
-    reason: event.reason
-  });
-}
-var init_on_request_stop_agent = __esm(() => {
-  init_stop_agent();
-});
-
-// src/commands/machine/daemon-start/handlers/ping.ts
-function handlePing() {
-  console.log(`   ↪ Responding: pong`);
-  return { result: "pong", failed: false };
-}
-
-// src/infrastructure/git/types.ts
-function makeGitStateKey(machineId, workingDir) {
-  return `${machineId}::${workingDir}`;
-}
-var FULL_DIFF_MAX_BYTES = 500000, COMMITS_PER_PAGE = 20;
-
-// src/infrastructure/git/git-reader.ts
-import { exec as exec2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-async function runGit(args, cwd) {
-  try {
-    const result = await execAsync2(`git ${args}`, {
-      cwd,
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_PAGER: "cat", NO_COLOR: "1" },
-      maxBuffer: FULL_DIFF_MAX_BYTES + 64 * 1024
-    });
-    return result;
-  } catch (err) {
-    return { error: err };
-  }
-}
-function isGitNotInstalled(message) {
-  return message.includes("command not found") || message.includes("ENOENT") || message.includes("not found") || message.includes("'git' is not recognized");
-}
-function isNotAGitRepo(message) {
-  return message.includes("not a git repository") || message.includes("Not a git repository");
-}
-function isPermissionDenied(message) {
-  return message.includes("Permission denied") || message.includes("EACCES");
-}
-function isEmptyRepo(stderr) {
-  return stderr.includes("does not have any commits yet") || stderr.includes("no commits yet") || stderr.includes("ambiguous argument 'HEAD'") || stderr.includes("unknown revision or path");
-}
-function classifyError(errMessage) {
-  if (isGitNotInstalled(errMessage)) {
-    return { status: "error", message: "git is not installed or not in PATH" };
-  }
-  if (isNotAGitRepo(errMessage)) {
-    return { status: "not_found" };
-  }
-  if (isPermissionDenied(errMessage)) {
-    return { status: "error", message: `Permission denied: ${errMessage}` };
-  }
-  return { status: "error", message: errMessage.trim() };
-}
-async function isGitRepo(workingDir) {
-  const result = await runGit("rev-parse --git-dir", workingDir);
-  if ("error" in result)
-    return false;
-  return result.stdout.trim().length > 0;
-}
-async function getBranch(workingDir) {
-  const result = await runGit("rev-parse --abbrev-ref HEAD", workingDir);
-  if ("error" in result) {
-    const errMsg = result.error.message;
-    if (errMsg.includes("unknown revision") || errMsg.includes("No such file or directory") || errMsg.includes("does not have any commits")) {
-      return { status: "available", branch: "HEAD" };
-    }
-    return classifyError(errMsg);
-  }
-  const branch = result.stdout.trim();
-  if (!branch) {
-    return { status: "error", message: "git rev-parse returned empty output" };
-  }
-  return { status: "available", branch };
-}
-async function isDirty(workingDir) {
-  const result = await runGit("status --porcelain", workingDir);
-  if ("error" in result)
-    return false;
-  return result.stdout.trim().length > 0;
-}
-function parseDiffStatLine(statLine) {
-  const filesMatch = statLine.match(/(\d+)\s+file/);
-  const insertMatch = statLine.match(/(\d+)\s+insertion/);
-  const deleteMatch = statLine.match(/(\d+)\s+deletion/);
-  return {
-    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
-    insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
-    deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0
-  };
-}
-async function getDiffStat(workingDir) {
-  const result = await runGit("diff HEAD --stat", workingDir);
-  if ("error" in result) {
-    const errMsg = result.error.message;
-    if (isEmptyRepo(result.error.message)) {
-      return { status: "no_commits" };
-    }
-    const classified = classifyError(errMsg);
-    if (classified.status === "not_found")
-      return { status: "not_found" };
-    return classified;
-  }
-  const output = result.stdout;
-  const stderr = result.stderr;
-  if (isEmptyRepo(stderr)) {
-    return { status: "no_commits" };
-  }
-  if (!output.trim()) {
-    return {
-      status: "available",
-      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
-    };
-  }
-  const lines = output.trim().split(`
-`);
-  const summaryLine = lines[lines.length - 1] ?? "";
-  const diffStat = parseDiffStatLine(summaryLine);
-  return { status: "available", diffStat };
-}
-async function getFullDiff(workingDir) {
-  const result = await runGit("diff HEAD", workingDir);
-  if ("error" in result) {
-    const errMsg = result.error.message;
-    if (isEmptyRepo(errMsg)) {
-      return { status: "no_commits" };
-    }
-    const classified = classifyError(errMsg);
-    if (classified.status === "not_found")
-      return { status: "not_found" };
-    return classified;
-  }
-  const stderr = result.stderr;
-  if (isEmptyRepo(stderr)) {
-    return { status: "no_commits" };
-  }
-  const raw = result.stdout;
-  const byteLength2 = Buffer.byteLength(raw, "utf8");
-  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
-    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
-    return { status: "truncated", content: truncated, truncated: true };
-  }
-  return { status: "available", content: raw, truncated: false };
-}
-async function getRecentCommits(workingDir, count = 20, skip = 0) {
-  const format = "%H%x00%h%x00%s%x00%an%x00%aI";
-  const skipArg = skip > 0 ? ` --skip=${skip}` : "";
-  const result = await runGit(`log -${count}${skipArg} --format=${format}`, workingDir);
-  if ("error" in result) {
-    return [];
-  }
-  const output = result.stdout.trim();
-  if (!output)
-    return [];
-  const commits = [];
-  for (const line of output.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    const parts = trimmed.split("\x00");
-    if (parts.length !== 5)
-      continue;
-    const [sha, shortSha, message, author, date] = parts;
-    commits.push({ sha, shortSha, message, author, date });
-  }
-  return commits;
-}
-async function getCommitDetail(workingDir, sha) {
-  const result = await runGit(`show ${sha} --format="" --stat -p`, workingDir);
-  if ("error" in result) {
-    const errMsg = result.error.message;
-    const classified = classifyError(errMsg);
-    if (classified.status === "not_found")
-      return { status: "not_found" };
-    if (isEmptyRepo(errMsg) || errMsg.includes("unknown revision") || errMsg.includes("bad object") || errMsg.includes("does not exist")) {
-      return { status: "not_found" };
-    }
-    return classified;
-  }
-  const raw = result.stdout;
-  const byteLength2 = Buffer.byteLength(raw, "utf8");
-  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
-    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
-    return { status: "truncated", content: truncated, truncated: true };
-  }
-  return { status: "available", content: raw, truncated: false };
-}
-async function getCommitMetadata(workingDir, sha) {
-  const format = "%s%x00%an%x00%aI";
-  const result = await runGit(`log -1 --format=${format} ${sha}`, workingDir);
-  if ("error" in result)
-    return null;
-  const output = result.stdout.trim();
-  if (!output)
-    return null;
-  const parts = output.split("\x00");
-  if (parts.length !== 3)
-    return null;
-  return { message: parts[0], author: parts[1], date: parts[2] };
-}
-var execAsync2;
-var init_git_reader = __esm(() => {
-  execAsync2 = promisify2(exec2);
-});
-
-// src/commands/machine/daemon-start/git-polling.ts
-function startGitPollingLoop(ctx) {
-  const timer = setInterval(() => {
-    runPollingTick(ctx).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Git polling tick failed: ${err.message}`);
-    });
-  }, GIT_POLLING_INTERVAL_MS);
-  timer.unref();
-  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git polling loop started (interval: ${GIT_POLLING_INTERVAL_MS}ms)`);
-  return {
-    stop: () => {
-      clearInterval(timer);
-      console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git polling loop stopped`);
-    }
-  };
-}
-function extractDiffStatFromShowOutput(content) {
-  for (const line of content.split(`
-`)) {
-    if (/\d+\s+file.*changed/.test(line)) {
-      return parseDiffStatLine(line);
+  const uniqueWorkingDirs = new Set(workspaces.map((ws) => ws.workingDir));
+  if (uniqueWorkingDirs.size === 0)
+    return;
+  for (const workingDir of uniqueWorkingDirs) {
+    try {
+      await pushSingleWorkspaceGitState(ctx, workingDir);
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed for ${workingDir}: ${err.message}`);
     }
   }
-  return { filesChanged: 0, insertions: 0, deletions: 0 };
 }
-async function processFullDiff(ctx, req) {
-  const result = await getFullDiff(req.workingDir);
-  if (result.status === "available" || result.status === "truncated") {
-    const diffStatResult = await getDiffStat(req.workingDir);
-    const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
-    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
+async function pushSingleWorkspaceGitState(ctx, workingDir) {
+  const stateKey = makeGitStateKey(ctx.machineId, workingDir);
+  const isRepo = await isGitRepo(workingDir);
+  if (!isRepo) {
+    const stateHash2 = "not_found";
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
-      workingDir: req.workingDir,
-      diffContent: result.content,
-      truncated: result.truncated,
-      diffStat
+      workingDir,
+      status: "not_found"
     });
-    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed: ${req.workingDir} (${diffStat.filesChanged} files, ${result.truncated ? "truncated" : "complete"})`);
-  } else {
-    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
+    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    return;
+  }
+  const [branchResult, dirtyResult, diffStatResult, commits] = await Promise.all([
+    getBranch(workingDir),
+    isDirty(workingDir),
+    getDiffStat(workingDir),
+    getRecentCommits(workingDir, COMMITS_PER_PAGE)
+  ]);
+  if (branchResult.status === "error") {
+    const stateHash2 = `error:${branchResult.message}`;
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
-      workingDir: req.workingDir,
-      diffContent: "",
-      truncated: false,
-      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
+      workingDir,
+      status: "error",
+      errorMessage: branchResult.message
     });
-    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed (empty): ${req.workingDir} (${result.status})`);
+    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    return;
+  }
+  if (branchResult.status === "not_found") {
+    return;
+  }
+  const openPRs = await getOpenPRsForBranch(workingDir, branchResult.branch);
+  const branch = branchResult.branch;
+  const isDirty2 = dirtyResult;
+  const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  const stateHash = createHash3("md5").update(JSON.stringify({ branch, isDirty: isDirty2, diffStat, shas: commits.map((c) => c.sha), prs: openPRs.map((pr) => pr.number) })).digest("hex");
+  if (ctx.lastPushedGitState.get(stateKey) === stateHash) {
+    return;
   }
+  await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "available",
+    branch,
+    isDirty: isDirty2,
+    diffStat,
+    recentCommits: commits,
+    hasMoreCommits,
+    openPullRequests: openPRs
+  });
+  ctx.lastPushedGitState.set(stateKey, stateHash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${isDirty2 ? ", dirty" : ", clean"})`);
+  prefetchMissingCommitDetails(ctx, workingDir, commits).catch((err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️  Commit pre-fetch failed for ${workingDir}: ${err.message}`);
+  });
 }
-async function processCommitDetail(ctx, req) {
-  if (!req.sha) {
-    throw new Error("commit_detail request missing sha");
+async function prefetchMissingCommitDetails(ctx, workingDir, commits) {
+  if (commits.length === 0)
+    return;
+  const shas = commits.map((c) => c.sha);
+  const missingShas = await ctx.deps.backend.query(api.workspaces.getMissingCommitShas, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    shas
+  });
+  if (missingShas.length === 0)
+    return;
+  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Pre-fetching ${missingShas.length} commit(s) for ${workingDir}`);
+  for (const sha of missingShas) {
+    try {
+      await prefetchSingleCommit(ctx, workingDir, sha, commits);
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Pre-fetch failed for ${sha.slice(0, 7)}: ${err.message}`);
+    }
   }
-  const [result, metadata] = await Promise.all([
-    getCommitDetail(req.workingDir, req.sha),
-    getCommitMetadata(req.workingDir, req.sha)
-  ]);
+}
+async function prefetchSingleCommit(ctx, workingDir, sha, commits) {
+  const metadata = commits.find((c) => c.sha === sha);
+  const result = await getCommitDetail(workingDir, sha);
   if (result.status === "not_found") {
     await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
-      workingDir: req.workingDir,
-      sha: req.sha,
+      workingDir,
+      sha,
       status: "not_found",
       message: metadata?.message,
       author: metadata?.author,
@@ -15498,8 +15158,8 @@ async function processCommitDetail(ctx, req) {
     await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
-      workingDir: req.workingDir,
-      sha: req.sha,
+      workingDir,
+      sha,
       status: "error",
       errorMessage: result.message,
       message: metadata?.message,
@@ -15512,8 +15172,8 @@ async function processCommitDetail(ctx, req) {
   await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
     sessionId: ctx.sessionId,
     machineId: ctx.machineId,
-    workingDir: req.workingDir,
-    sha: req.sha,
+    workingDir,
+    sha,
     status: "available",
     diffContent: result.content,
     truncated: result.truncated,
@@ -15522,371 +15182,876 @@ async function processCommitDetail(ctx, req) {
     date: metadata?.date,
     diffStat
   });
-  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Commit detail pushed: ${req.sha.slice(0, 7)} in ${req.workingDir}`);
+  console.log(`[${formatTimestamp()}] ✅ Pre-fetched: ${sha.slice(0, 7)} in ${workingDir}`);
 }
-async function processMoreCommits(ctx, req) {
-  const offset = req.offset ?? 0;
-  const commits = await getRecentCommits(req.workingDir, COMMITS_PER_PAGE, offset);
-  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
-  await ctx.deps.backend.mutation(api.workspaces.appendMoreCommits, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId,
-    workingDir: req.workingDir,
-    commits,
-    hasMoreCommits
-  });
-  console.log(`[${formatTimestamp()}] \uD83D\uDCDC More commits appended: ${req.workingDir} (+${commits.length} commits, offset=${offset})`);
+var init_git_heartbeat = __esm(() => {
+  init_git_subscription();
+  init_api3();
+  init_git_reader();
+});
+
+// src/commands/machine/daemon-start/handlers/ping.ts
+function handlePing() {
+  console.log(`   ↪ Responding: pong`);
+  return { result: "pong", failed: false };
 }
-async function runPollingTick(ctx) {
-  const requests = await ctx.deps.backend.query(api.workspaces.getPendingRequests, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId
-  });
-  if (requests.length === 0)
+
+// src/commands/machine/daemon-start/handlers/state-recovery.ts
+async function recoverAgentState(ctx) {
+  await ctx.deps.agentProcessManager.recover();
+  const activeSlots = ctx.deps.agentProcessManager.listActive();
+  if (activeSlots.length === 0) {
+    console.log(`   No active agents after recovery`);
     return;
-  for (const req of requests) {
+  }
+  const chatroomIds = new Set(activeSlots.map((s) => s.chatroomId));
+  let registeredCount = 0;
+  for (const chatroomId of chatroomIds) {
     try {
-      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+      const configsResult = await ctx.deps.backend.query(api.machines.getMachineAgentConfigs, {
         sessionId: ctx.sessionId,
-        requestId: req._id,
-        status: "processing"
+        chatroomId
       });
-      switch (req.requestType) {
-        case "full_diff":
-          await processFullDiff(ctx, req);
-          break;
-        case "commit_detail":
-          await processCommitDetail(ctx, req);
-          break;
-        case "more_commits":
-          await processMoreCommits(ctx, req);
-          break;
+      for (const config3 of configsResult.configs) {
+        if (config3.machineId === ctx.machineId && config3.workingDir) {
+          registeredCount++;
+          ctx.deps.backend.mutation(api.workspaces.registerWorkspace, {
+            sessionId: ctx.sessionId,
+            chatroomId,
+            machineId: ctx.machineId,
+            workingDir: config3.workingDir,
+            hostname: ctx.config?.hostname ?? "unknown",
+            registeredBy: config3.role
+          }).catch((err) => {
+            console.warn(`[daemon] ⚠️ Failed to register workspace on recovery: ${err.message}`);
+          });
+        }
       }
-      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
-        sessionId: ctx.sessionId,
-        requestId: req._id,
-        status: "done"
+    } catch {}
+  }
+  if (registeredCount > 0) {
+    console.log(`   \uD83D\uDD00 Registered ${registeredCount} workspace(s) on recovery`);
+  }
+}
+var init_state_recovery = __esm(() => {
+  init_api3();
+});
+
+// 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/events/daemon/agent/on-agent-exited.ts
+function onAgentExited(ctx, payload) {
+  ctx.deps.agentProcessManager.handleExit({
+    chatroomId: payload.chatroomId,
+    role: payload.role,
+    pid: payload.pid,
+    code: payload.code,
+    signal: payload.signal
+  });
+}
+
+// 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_started();
+  init_on_agent_stopped();
+});
+
+// src/infrastructure/services/harness-spawning/rate-limiter.ts
+class SpawnRateLimiter {
+  config;
+  buckets = new Map;
+  constructor(config3 = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config3 };
+  }
+  tryConsume(chatroomId, reason) {
+    if (reason.startsWith("user.")) {
+      return { allowed: true };
+    }
+    const bucket = this._getOrCreateBucket(chatroomId);
+    this._refill(bucket);
+    if (bucket.tokens < 1) {
+      const elapsed = Date.now() - bucket.lastRefillAt;
+      const retryAfterMs = this.config.refillRateMs - elapsed;
+      console.warn(`⚠️ [RateLimiter] Agent spawn rate-limited for chatroom ${chatroomId} (reason: ${reason}). Retry after ${retryAfterMs}ms`);
+      return { allowed: false, retryAfterMs };
+    }
+    bucket.tokens -= 1;
+    const remaining = Math.floor(bucket.tokens);
+    if (remaining <= LOW_TOKEN_THRESHOLD) {
+      console.warn(`⚠️ [RateLimiter] Agent spawn tokens running low for chatroom ${chatroomId} (${remaining}/${this.config.maxTokens} remaining)`);
+    }
+    return { allowed: true };
+  }
+  getStatus(chatroomId) {
+    const bucket = this._getOrCreateBucket(chatroomId);
+    this._refill(bucket);
+    return {
+      remaining: Math.floor(bucket.tokens),
+      total: this.config.maxTokens
+    };
+  }
+  _getOrCreateBucket(chatroomId) {
+    if (!this.buckets.has(chatroomId)) {
+      this.buckets.set(chatroomId, {
+        tokens: this.config.initialTokens,
+        lastRefillAt: Date.now()
       });
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️  Failed to process ${req.requestType} request: ${err.message}`);
-      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
-        sessionId: ctx.sessionId,
-        requestId: req._id,
-        status: "error"
-      }).catch(() => {});
     }
+    return this.buckets.get(chatroomId);
+  }
+  _refill(bucket) {
+    const now = Date.now();
+    const elapsed = now - bucket.lastRefillAt;
+    if (elapsed >= this.config.refillRateMs) {
+      const tokensToAdd = Math.floor(elapsed / this.config.refillRateMs);
+      bucket.tokens = Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
+      bucket.lastRefillAt += tokensToAdd * this.config.refillRateMs;
+    }
+  }
+}
+var DEFAULT_CONFIG, LOW_TOKEN_THRESHOLD = 1;
+var init_rate_limiter = __esm(() => {
+  DEFAULT_CONFIG = {
+    maxTokens: 5,
+    refillRateMs: 60000,
+    initialTokens: 5
+  };
+});
+
+// src/infrastructure/services/harness-spawning/harness-spawning-service.ts
+class HarnessSpawningService {
+  rateLimiter;
+  concurrentAgents = new Map;
+  constructor({ rateLimiter }) {
+    this.rateLimiter = rateLimiter;
+  }
+  shouldAllowSpawn(chatroomId, reason) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    if (current >= MAX_CONCURRENT_AGENTS_PER_CHATROOM) {
+      console.warn(`⚠️ [HarnessSpawningService] Concurrent agent limit reached for chatroom ${chatroomId} ` + `(${current}/${MAX_CONCURRENT_AGENTS_PER_CHATROOM} active agents). Spawn rejected.`);
+      return { allowed: false };
+    }
+    const result = this.rateLimiter.tryConsume(chatroomId, reason);
+    if (!result.allowed) {
+      console.warn(`⚠️ [HarnessSpawningService] Spawn blocked by rate limiter for chatroom ${chatroomId} ` + `(reason: ${reason}).`);
+    }
+    return result;
+  }
+  recordSpawn(chatroomId) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    this.concurrentAgents.set(chatroomId, current + 1);
+  }
+  recordExit(chatroomId) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    const next = Math.max(0, current - 1);
+    this.concurrentAgents.set(chatroomId, next);
+  }
+  getConcurrentCount(chatroomId) {
+    return this.concurrentAgents.get(chatroomId) ?? 0;
   }
 }
-var GIT_POLLING_INTERVAL_MS = 5000;
-var init_git_polling = __esm(() => {
-  init_api3();
-  init_git_reader();
+var MAX_CONCURRENT_AGENTS_PER_CHATROOM = 10;
+
+// src/infrastructure/services/harness-spawning/index.ts
+var init_harness_spawning = __esm(() => {
+  init_rate_limiter();
 });
 
-// src/commands/machine/daemon-start/git-heartbeat.ts
-import { createHash as createHash2 } from "node:crypto";
-async function pushGitState(ctx) {
-  if (ctx.activeWorkingDirs.size === 0)
-    return;
-  for (const workingDir of ctx.activeWorkingDirs) {
-    try {
-      await pushSingleWorkspaceGitState(ctx, workingDir);
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed for ${workingDir}: ${err.message}`);
-    }
-  }
+// src/infrastructure/machine/crash-loop-tracker.ts
+class CrashLoopTracker {
+  history = new Map;
+  record(chatroomId, role, now = Date.now()) {
+    const key = `${chatroomId}:${role.toLowerCase()}`;
+    const windowStart = now - CRASH_LOOP_WINDOW_MS;
+    const raw = this.history.get(key) ?? [];
+    const recent = raw.filter((ts) => ts >= windowStart);
+    recent.push(now);
+    this.history.set(key, recent);
+    const restartCount = recent.length;
+    const allowed = restartCount <= CRASH_LOOP_MAX_RESTARTS;
+    return { allowed, restartCount, windowMs: CRASH_LOOP_WINDOW_MS };
+  }
+  clear(chatroomId, role) {
+    const key = `${chatroomId}:${role.toLowerCase()}`;
+    this.history.delete(key);
+  }
+  getCount(chatroomId, role, now = Date.now()) {
+    const key = `${chatroomId}:${role.toLowerCase()}`;
+    const windowStart = now - CRASH_LOOP_WINDOW_MS;
+    const raw = this.history.get(key) ?? [];
+    return raw.filter((ts) => ts >= windowStart).length;
+  }
+}
+var CRASH_LOOP_MAX_RESTARTS = 3, CRASH_LOOP_WINDOW_MS;
+var init_crash_loop_tracker = __esm(() => {
+  CRASH_LOOP_WINDOW_MS = 5 * 60 * 1000;
+});
+
+// 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";
 }
-async function pushSingleWorkspaceGitState(ctx, workingDir) {
-  const stateKey = makeGitStateKey(ctx.machineId, workingDir);
-  const isRepo = await isGitRepo(workingDir);
-  if (!isRepo) {
-    const stateHash2 = "not_found";
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+
+// src/infrastructure/services/agent-process-manager/agent-process-manager.ts
+function agentKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+
+class AgentProcessManager {
+  deps;
+  slots = new Map;
+  pendingStopReasons = new Map;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async ensureRunning(opts) {
+    const key = agentKey2(opts.chatroomId, opts.role);
+    const slot = this.getOrCreateSlot(key);
+    if (slot.state === "running") {
+      return { success: true, pid: slot.pid };
+    }
+    if (slot.state === "spawning" && slot.pendingOperation) {
+      return slot.pendingOperation;
+    }
+    if (slot.state === "stopping" && slot.pendingOperation) {
+      await slot.pendingOperation;
+    }
+    const operation = this.doEnsureRunning(key, slot, opts);
+    slot.pendingOperation = operation;
+    return operation;
+  }
+  async stop(opts) {
+    const key = agentKey2(opts.chatroomId, opts.role);
+    const slot = this.slots.get(key);
+    if (!slot || slot.state === "idle") {
+      return { success: true };
+    }
+    if (slot.state === "stopping" && slot.pendingOperation) {
+      await slot.pendingOperation;
+      return { success: true };
+    }
+    const pid = slot.pid;
+    if (!pid) {
+      slot.state = "idle";
+      slot.pendingOperation = undefined;
+      return { success: true };
+    }
+    this.pendingStopReasons.set(key, opts.reason);
+    slot.state = "stopping";
+    const operation = this.doStop(key, slot, pid, opts);
+    slot.pendingOperation = operation;
+    await operation;
+    return { success: true };
+  }
+  handleExit(opts) {
+    const key = agentKey2(opts.chatroomId, opts.role);
+    const slot = this.slots.get(key);
+    if (!slot || slot.pid !== opts.pid) {
       return;
-    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      workingDir,
-      status: "not_found"
+    }
+    if (slot.state === "stopping") {
+      return;
+    }
+    const intentionalReason = this.pendingStopReasons.get(key);
+    this.pendingStopReasons.delete(key);
+    const stopReason = intentionalReason ?? resolveStopReason(opts.code, opts.signal, false);
+    this.deps.spawning.recordExit(opts.chatroomId);
+    const harness = slot.harness;
+    const model = slot.model;
+    const workingDir = slot.workingDir;
+    slot.state = "idle";
+    slot.pid = undefined;
+    slot.startedAt = undefined;
+    slot.pendingOperation = undefined;
+    this.deps.backend.mutation(api.machines.recordAgentExited, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      pid: opts.pid,
+      stopReason,
+      stopSignal: stopReason === "agent_process.signal" ? opts.signal ?? undefined : undefined,
+      exitCode: opts.code ?? undefined,
+      signal: opts.signal ?? undefined,
+      agentHarness: harness
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
-    return;
-  }
-  const [branchResult, dirtyResult, diffStatResult, commits] = await Promise.all([
-    getBranch(workingDir),
-    isDirty(workingDir),
-    getDiffStat(workingDir),
-    getRecentCommits(workingDir, COMMITS_PER_PAGE)
-  ]);
-  if (branchResult.status === "error") {
-    const stateHash2 = `error:${branchResult.message}`;
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+    this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
+    for (const service of this.deps.agentServices.values()) {
+      service.untrack(opts.pid);
+    }
+    const isIntentionalStop = stopReason === "user.stop" || stopReason === "platform.team_switch";
+    const isDaemonRespawn = stopReason === "daemon.respawn";
+    if (isIntentionalStop) {
+      this.deps.crashLoop.clear(opts.chatroomId, opts.role);
       return;
-    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
+    }
+    if (isDaemonRespawn) {
+      return;
+    }
+    if (!harness || !workingDir) {
+      console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
+      return;
+    }
+    this.ensureRunning({
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      agentHarness: harness,
+      model,
       workingDir,
-      status: "error",
-      errorMessage: branchResult.message
+      reason: "platform.crash_recovery"
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to restart agent: ${err.message}`);
+      this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        error: err.message
+      }).catch((emitErr) => {
+        console.log(`   ⚠️  Failed to emit startFailed event: ${emitErr.message}`);
+      });
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
-    return;
   }
-  if (branchResult.status === "not_found") {
-    return;
+  getSlot(chatroomId, role) {
+    return this.slots.get(agentKey2(chatroomId, role));
   }
-  const branch = branchResult.branch;
-  const isDirty2 = dirtyResult;
-  const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
-  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
-  const stateHash = createHash2("md5").update(JSON.stringify({ branch, isDirty: isDirty2, diffStat, shas: commits.map((c) => c.sha) })).digest("hex");
-  if (ctx.lastPushedGitState.get(stateKey) === stateHash) {
-    return;
+  listActive() {
+    const result = [];
+    for (const [key, slot] of this.slots) {
+      if (slot.state === "running" || slot.state === "spawning") {
+        const [chatroomId, role] = key.split(":");
+        result.push({ chatroomId, role, slot });
+      }
+    }
+    return result;
   }
-  await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId,
-    workingDir,
-    status: "available",
-    branch,
-    isDirty: isDirty2,
-    diffStat,
-    recentCommits: commits,
-    hasMoreCommits
-  });
-  ctx.lastPushedGitState.set(stateKey, stateHash);
-  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${isDirty2 ? ", dirty" : ", clean"})`);
-  prefetchMissingCommitDetails(ctx, workingDir, commits).catch((err) => {
-    console.warn(`[${formatTimestamp()}] ⚠️  Commit pre-fetch failed for ${workingDir}: ${err.message}`);
-  });
-}
-async function prefetchMissingCommitDetails(ctx, workingDir, commits) {
-  if (commits.length === 0)
-    return;
-  const shas = commits.map((c) => c.sha);
-  const missingShas = await ctx.deps.backend.query(api.workspaces.getMissingCommitShas, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId,
-    workingDir,
-    shas
-  });
-  if (missingShas.length === 0)
-    return;
-  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Pre-fetching ${missingShas.length} commit(s) for ${workingDir}`);
-  for (const sha of missingShas) {
-    try {
-      await prefetchSingleCommit(ctx, workingDir, sha, commits);
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️  Pre-fetch failed for ${sha.slice(0, 7)}: ${err.message}`);
+  async recover() {
+    const entries = this.deps.persistence.listAgentEntries(this.deps.machineId);
+    let recovered = 0;
+    let cleaned = 0;
+    for (const { chatroomId, role, entry } of entries) {
+      const key = agentKey2(chatroomId, role);
+      let alive = false;
+      try {
+        this.deps.processes.kill(entry.pid, 0);
+        alive = true;
+      } catch {
+        alive = false;
+      }
+      if (alive) {
+        this.slots.set(key, {
+          state: "running",
+          pid: entry.pid,
+          harness: entry.harness
+        });
+        recovered++;
+      } else {
+        this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+        cleaned++;
+      }
     }
+    console.log(`[AgentProcessManager] Recovery: ${recovered} alive, ${cleaned} cleaned up`);
   }
-}
-async function prefetchSingleCommit(ctx, workingDir, sha, commits) {
-  const metadata = commits.find((c) => c.sha === sha);
-  const result = await getCommitDetail(workingDir, sha);
-  if (result.status === "not_found") {
-    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      workingDir,
-      sha,
-      status: "not_found",
-      message: metadata?.message,
-      author: metadata?.author,
-      date: metadata?.date
-    });
-    return;
+  getOrCreateSlot(key) {
+    let slot = this.slots.get(key);
+    if (!slot) {
+      slot = { state: "idle" };
+      this.slots.set(key, slot);
+    }
+    return slot;
   }
-  if (result.status === "error") {
-    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      workingDir,
-      sha,
-      status: "error",
-      errorMessage: result.message,
-      message: metadata?.message,
-      author: metadata?.author,
-      date: metadata?.date
-    });
-    return;
+  async doEnsureRunning(key, slot, opts) {
+    slot.state = "spawning";
+    try {
+      const spawnCheck = this.deps.spawning.shouldAllowSpawn(opts.chatroomId, opts.reason);
+      if (!spawnCheck.allowed) {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: "rate_limited" };
+      }
+      if (opts.reason === "platform.crash_recovery") {
+        const loopCheck = this.deps.crashLoop.record(opts.chatroomId, opts.role);
+        if (!loopCheck.allowed) {
+          this.deps.backend.mutation(api.machines.emitRestartLimitReached, {
+            sessionId: this.deps.sessionId,
+            machineId: this.deps.machineId,
+            chatroomId: opts.chatroomId,
+            role: opts.role,
+            restartCount: loopCheck.restartCount,
+            windowMs: loopCheck.windowMs
+          }).catch((err) => {
+            console.log(`   ⚠️  Failed to emit restartLimitReached event: ${err.message}`);
+          });
+          slot.state = "idle";
+          slot.pendingOperation = undefined;
+          return { success: false, error: "crash_loop" };
+        }
+      }
+      try {
+        const dirStat = await this.deps.fs.stat(opts.workingDir);
+        if (!dirStat.isDirectory()) {
+          slot.state = "idle";
+          slot.pendingOperation = undefined;
+          return {
+            success: false,
+            error: `Working directory is not a directory: ${opts.workingDir}`
+          };
+        }
+      } catch {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: `Working directory does not exist: ${opts.workingDir}` };
+      }
+      if (slot.pid) {
+        try {
+          this.deps.processes.kill(-slot.pid, "SIGTERM");
+        } catch {}
+        slot.pid = undefined;
+      }
+      let initPromptResult;
+      try {
+        initPromptResult = await this.deps.backend.query(api.messages.getInitPrompt, {
+          sessionId: this.deps.sessionId,
+          chatroomId: opts.chatroomId,
+          role: opts.role,
+          convexUrl: this.deps.convexUrl
+        });
+      } catch (e) {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: `Failed to fetch init prompt: ${e.message}` };
+      }
+      if (!initPromptResult?.prompt) {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: "Failed to fetch init prompt from backend" };
+      }
+      const service = this.deps.agentServices.get(opts.agentHarness);
+      if (!service) {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: `Unknown agent harness: ${opts.agentHarness}` };
+      }
+      let spawnResult;
+      try {
+        spawnResult = await service.spawn({
+          workingDir: opts.workingDir,
+          prompt: initPromptResult.initialMessage,
+          systemPrompt: initPromptResult.rolePrompt,
+          model: opts.model,
+          context: {
+            machineId: this.deps.machineId,
+            chatroomId: opts.chatroomId,
+            role: opts.role
+          }
+        });
+      } catch (e) {
+        slot.state = "idle";
+        slot.pendingOperation = undefined;
+        return { success: false, error: `Failed to spawn agent: ${e.message}` };
+      }
+      const { pid } = spawnResult;
+      this.deps.spawning.recordSpawn(opts.chatroomId);
+      slot.state = "running";
+      slot.pid = pid;
+      slot.harness = opts.agentHarness;
+      slot.model = opts.model;
+      slot.workingDir = opts.workingDir;
+      slot.startedAt = this.deps.clock.now();
+      slot.pendingOperation = undefined;
+      this.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        pid,
+        model: opts.model,
+        reason: opts.reason
+      }).catch((err) => {
+        console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
+      });
+      try {
+        this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness);
+      } catch {}
+      spawnResult.onExit(({ code: code2, signal }) => {
+        this.handleExit({
+          chatroomId: opts.chatroomId,
+          role: opts.role,
+          pid,
+          code: code2,
+          signal
+        });
+      });
+      if (spawnResult.onAgentEnd) {
+        spawnResult.onAgentEnd(() => {
+          try {
+            this.deps.processes.kill(-pid, "SIGTERM");
+          } catch {}
+        });
+      }
+      let lastReportedTokenAt = 0;
+      spawnResult.onOutput(() => {
+        const now = this.deps.clock.now();
+        if (now - lastReportedTokenAt >= 30000) {
+          lastReportedTokenAt = now;
+          this.deps.backend.mutation(api.participants.updateTokenActivity, {
+            sessionId: this.deps.sessionId,
+            chatroomId: opts.chatroomId,
+            role: opts.role
+          }).catch(() => {});
+        }
+      });
+      return { success: true, pid };
+    } catch (e) {
+      slot.state = "idle";
+      slot.pendingOperation = undefined;
+      return { success: false, error: `Unexpected error: ${e.message}` };
+    }
+  }
+  async doStop(key, slot, pid, opts) {
+    try {
+      try {
+        this.deps.processes.kill(-pid, "SIGTERM");
+      } catch {}
+      let dead = false;
+      for (let i2 = 0;i2 < 20; i2++) {
+        await this.deps.clock.delay(500);
+        try {
+          this.deps.processes.kill(pid, 0);
+        } catch {
+          dead = true;
+          break;
+        }
+      }
+      if (!dead) {
+        try {
+          this.deps.processes.kill(-pid, "SIGKILL");
+        } catch {}
+        for (let i2 = 0;i2 < 10; i2++) {
+          await this.deps.clock.delay(500);
+          try {
+            this.deps.processes.kill(pid, 0);
+          } catch {
+            dead = true;
+            break;
+          }
+        }
+      }
+    } catch {}
+    slot.state = "idle";
+    slot.pid = undefined;
+    slot.startedAt = undefined;
+    slot.pendingOperation = undefined;
+    this.deps.backend.mutation(api.machines.recordAgentExited, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      pid,
+      stopReason: opts.reason,
+      exitCode: undefined,
+      signal: undefined,
+      agentHarness: slot.harness
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
+    });
+    this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
+    for (const service of this.deps.agentServices.values()) {
+      service.untrack(pid);
+    }
+    return { success: true };
   }
-  const diffStat = extractDiffStatFromShowOutput(result.content);
-  await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
-    sessionId: ctx.sessionId,
-    machineId: ctx.machineId,
-    workingDir,
-    sha,
-    status: "available",
-    diffContent: result.content,
-    truncated: result.truncated,
-    message: metadata?.message,
-    author: metadata?.author,
-    date: metadata?.date,
-    diffStat
-  });
-  console.log(`[${formatTimestamp()}] ✅ Pre-fetched: ${sha.slice(0, 7)} in ${workingDir}`);
 }
-var init_git_heartbeat = __esm(() => {
+var init_agent_process_manager = __esm(() => {
   init_api3();
-  init_git_reader();
-  init_git_polling();
 });
 
-// src/infrastructure/services/remote-agents/harness-restart-policy.ts
-class OpenCodeRestartPolicy {
-  id = "opencode";
-  shouldStartAgent(params) {
-    const { task, agentConfig } = params;
-    if (agentConfig.desiredState !== "running") {
-      return false;
-    }
-    if (agentConfig.circuitState === "open") {
-      return false;
-    }
-    if (task.status === "in_progress") {
-      return agentConfig.spawnedAgentPid == null;
-    }
-    if (task.status === "pending" || task.status === "acknowledged") {
-      return agentConfig.spawnedAgentPid == null;
+// 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 false;
   }
+  return results;
 }
-
-class PiRestartPolicy {
-  id = "pi";
-  shouldStartAgent(params, context) {
-    const { task, agentConfig } = params;
-    if (agentConfig.desiredState !== "running") {
-      return false;
-    }
-    if (agentConfig.circuitState === "open") {
-      return false;
-    }
-    if (task.status === "in_progress") {
-      return agentConfig.spawnedAgentPid == null;
-    }
-    if (task.status === "pending" || task.status === "acknowledged") {
-      if (agentConfig.spawnedAgentPid == null) {
-        return true;
+function createDefaultDeps19() {
+  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
+    },
+    machine: {
+      clearAgentPid,
+      persistAgentPid,
+      listAgentEntries,
+      persistEventCursor,
+      loadEventCursor
+    },
+    clock: {
+      now: () => Date.now(),
+      delay: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
+    },
+    spawning: new HarnessSpawningService({ rateLimiter: new SpawnRateLimiter }),
+    agentProcessManager: null
+  };
+}
+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}`);
       }
     }
-    if (task.status !== "pending" && task.status !== "acknowledged") {
-      return false;
-    }
-    if (!context?.agentEndedTurn) {
-      return false;
-    }
-    const key = `${task.chatroomId}:${agentConfig.role}`;
-    const hasEndedTurn = context.agentEndedTurn.get(key);
-    return hasEndedTurn === true;
+    console.error(`
+Run: chatroom auth login`);
+    releaseLock();
+    process.exit(1);
   }
+  return sessionId;
 }
-function getRestartPolicyForHarness(harness) {
-  switch (harness) {
-    case "opencode":
-      return new OpenCodeRestartPolicy;
-    case "pi":
-      return new PiRestartPolicy;
-    default:
-      return {
-        id: harness,
-        shouldStartAgent: () => 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);
   }
 }
-
-// src/commands/machine/daemon-start/task-monitor.ts
-function canAttemptRestart(chatroomId, role, now) {
-  const key = `${chatroomId}:${role.toLowerCase()}`;
-  const lastAttempt = lastRestartAttempt.get(key) ?? 0;
-  return now - lastAttempt >= RESTART_COOLDOWN_MS;
-}
-function recordRestartAttempt(chatroomId, role, now) {
-  const key = `${chatroomId}:${role.toLowerCase()}`;
-  lastRestartAttempt.set(key, now);
-}
-function startTaskMonitor(ctx) {
-  let unsubscribe = null;
-  let isRunning = true;
-  const startMonitoring = async () => {
-    try {
-      const wsClient2 = await getConvexWsClient();
-      const agentEndContext = {
-        agentEndedTurn: ctx.agentEndedTurn
-      };
-      unsubscribe = wsClient2.onUpdate(api.machines.getAssignedTasks, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId
-      }, async (result) => {
-        if (!result?.tasks || result.tasks.length === 0)
-          return;
-        const now = Date.now();
-        for (const taskInfo of result.tasks) {
-          const { task, agentConfig } = {
-            task: {
-              taskId: taskInfo.taskId,
-              chatroomId: taskInfo.chatroomId,
-              status: taskInfo.status,
-              assignedTo: taskInfo.assignedTo,
-              updatedAt: taskInfo.updatedAt,
-              createdAt: taskInfo.createdAt
-            },
-            agentConfig: taskInfo.agentConfig
-          };
-          const policy = getRestartPolicyForHarness(agentConfig.agentHarness);
-          const shouldStart = policy.shouldStartAgent({ task, agentConfig }, agentEndContext);
-          if (!shouldStart)
-            continue;
-          if (!canAttemptRestart(task.chatroomId, agentConfig.role, now)) {
-            continue;
-          }
-          if (!agentConfig.workingDir) {
-            console.warn(`[${formatTimestamp()}] ⚠️  Missing workingDir for ${task.chatroomId}/${agentConfig.role}` + ` — skipping`);
-            continue;
-          }
-          console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Task monitor: starting agent for ` + `${task.chatroomId}/${agentConfig.role} (harness: ${agentConfig.agentHarness})`);
-          recordRestartAttempt(task.chatroomId, agentConfig.role, now);
-          try {
-            await executeStartAgent(ctx, {
-              chatroomId: task.chatroomId,
-              role: agentConfig.role,
-              agentHarness: agentConfig.agentHarness,
-              model: agentConfig.model,
-              workingDir: agentConfig.workingDir,
-              reason: "daemon.task_monitor"
-            });
-          } catch (err) {
-            console.error(`[${formatTimestamp()}] ❌ Task monitor failed to start agent ` + `for ${task.chatroomId}/${agentConfig.role}: ${err.message}`);
-          }
-        }
-      });
-      console.log(`[${formatTimestamp()}] \uD83D\uDD0D Task monitor started`);
-    } catch (err) {
-      if (isRunning) {
-        console.error(`[${formatTimestamp()}] ❌ Task monitor error: ${err.message}`);
-        setTimeout(startMonitoring, 5000);
-      }
-    }
-  };
-  startMonitoring();
-  return {
-    stop: () => {
-      isRunning = false;
-      if (unsubscribe) {
-        unsubscribe();
-        unsubscribe = null;
-      }
+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 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
+    });
+  } catch (error) {
+    if (isNetworkError(error)) {
+      formatConnectivityError(error, convexUrl);
+    } else {
+      console.error(`❌ Failed to update daemon status: ${error.message}`);
     }
+    releaseLock();
+    process.exit(1);
+  }
+}
+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`);
+  }
+}
+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 = createDefaultDeps19();
+  deps.backend.mutation = (endpoint, args) => client2.mutation(endpoint, args);
+  deps.backend.query = (endpoint, args) => client2.query(endpoint, args);
+  deps.agentProcessManager = new AgentProcessManager({
+    agentServices,
+    backend: deps.backend,
+    sessionId: typedSessionId,
+    machineId,
+    processes: deps.processes,
+    clock: deps.clock,
+    fs: deps.fs,
+    persistence: deps.machine,
+    spawning: deps.spawning,
+    crashLoop: new CrashLoopTracker,
+    convexUrl
+  });
+  const events = new DaemonEventBus;
+  const ctx = {
+    client: client2,
+    sessionId: typedSessionId,
+    machineId,
+    config: config3,
+    deps,
+    events,
+    agentServices,
+    lastPushedGitState: new Map
   };
+  registerEventListeners(ctx);
+  logStartup(ctx, availableModels);
+  await recoverState(ctx);
+  return ctx;
 }
-var RESTART_COOLDOWN_MS = 60000, lastRestartAttempt;
-var init_task_monitor = __esm(() => {
+var init_init2 = __esm(() => {
+  init_state_recovery();
   init_api3();
+  init_register_listeners();
+  init_storage();
   init_client2();
-  init_start_agent();
-  lastRestartAttempt = new Map;
+  init_machine();
+  init_harness_spawning();
+  init_crash_loop_tracker();
+  init_agent_process_manager();
+  init_remote_agents();
+  init_error_formatting();
+  init_version();
+  init_pid();
+});
+
+// src/events/lifecycle/on-daemon-shutdown.ts
+async function onDaemonShutdown(ctx) {
+  const activeAgents = ctx.deps.agentProcessManager.listActive();
+  if (activeAgents.length > 0) {
+    console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s)...`);
+    await Promise.allSettled(activeAgents.map(async ({ chatroomId, role, slot }) => {
+      try {
+        await ctx.deps.agentProcessManager.stop({
+          chatroomId,
+          role,
+          reason: "user.stop"
+        });
+        console.log(`   Stopped ${role} (PID ${slot.pid})`);
+      } catch (e) {
+        console.log(`   ⚠️  Failed to stop ${role}: ${e.message}`);
+      }
+    }));
+    console.log(`[${formatTimestamp()}] All agents stopped`);
+  }
+  try {
+    await ctx.deps.backend.mutation(api.machines.updateDaemonStatus, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      connected: false
+    });
+  } catch {}
+}
+var init_on_daemon_shutdown = __esm(() => {
+  init_api3();
 });
 
 // src/commands/machine/daemon-start/command-loop.ts
@@ -15975,15 +16140,14 @@ async function startCommandLoop(ctx) {
     });
   }, DAEMON_HEARTBEAT_INTERVAL_MS);
   heartbeatTimer.unref();
-  const gitPollingHandle = startGitPollingLoop(ctx);
-  const taskMonitorHandle = startTaskMonitor(ctx);
+  let gitSubscriptionHandle = null;
   pushGitState(ctx).catch(() => {});
   const shutdown = async () => {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
     clearInterval(heartbeatTimer);
-    gitPollingHandle.stop();
-    taskMonitorHandle.stop();
+    if (gitSubscriptionHandle)
+      gitSubscriptionHandle.stop();
     await onDaemonShutdown(ctx);
     releaseLock();
     process.exit(0);
@@ -15992,6 +16156,7 @@ async function startCommandLoop(ctx) {
   process.on("SIGTERM", shutdown);
   process.on("SIGHUP", shutdown);
   const wsClient2 = await getConvexWsClient();
+  gitSubscriptionHandle = startGitRequestSubscription(ctx, wsClient2);
   console.log(`
 Listening for commands...`);
   console.log(`Press Ctrl+C to stop
@@ -16008,7 +16173,7 @@ Listening for commands...`);
     evictStaleDedupEntries(processedCommandIds, processedPingIds, processedGitRefreshIds);
     for (const event of result.events) {
       try {
-        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
+        console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type} (id: ${event._id})`);
         await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds, processedGitRefreshIds);
       } catch (err) {
         console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
@@ -16025,17 +16190,16 @@ Listening for commands...`);
 }
 var MODEL_REFRESH_INTERVAL_MS;
 var init_command_loop = __esm(() => {
-  init_api3();
-  init_client2();
-  init_machine();
-  init_on_daemon_shutdown();
-  init_init2();
   init_on_request_start_agent();
   init_on_request_stop_agent();
   init_pid();
-  init_git_polling();
   init_git_heartbeat();
-  init_task_monitor();
+  init_git_subscription();
+  init_init2();
+  init_api3();
+  init_on_daemon_shutdown();
+  init_client2();
+  init_machine();
   MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 });
 
@@ -16047,8 +16211,6 @@ async function daemonStart() {
 var init_daemon_start = __esm(() => {
   init_command_loop();
   init_init2();
-  init_start_agent();
-  init_stop_agent();
   init_state_recovery();
 });
 
@@ -16706,7 +16868,7 @@ program2.command("task-started").description("[LEGACY] Acknowledge a task and op
     noClassify: skipClassification
   });
 });
-program2.command("classify").description("Classify a task's origin message (entry-point role only). Use task-started --no-classify for handoffs.").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (must be entry-point role)").requiredOption("--task-id <taskId>", "Task ID to acknowledge").requiredOption("--origin-message-classification <type>", "Original message classification: question, new_feature, or follow_up").action(async (options) => {
+program2.command("classify").description("Classify a task's origin message (entry-point role only).").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (must be entry-point role)").requiredOption("--task-id <taskId>", "Task ID to acknowledge").requiredOption("--origin-message-classification <type>", "Original message classification: question, new_feature, or follow_up").action(async (options) => {
   await maybeRequireAuth();
   const validClassifications = ["question", "new_feature", "follow_up"];
   if (!validClassifications.includes(options.originMessageClassification)) {
@@ -16792,12 +16954,14 @@ program2.command("report-progress").description("Report progress on current task
   });
 });
 var backlogCommand = program2.command("backlog").description("Manage task queue and backlog");
-backlogCommand.command("list").description("List active backlog items").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--limit <n>", "Maximum number of items to show").action(async (options) => {
+backlogCommand.command("list").description("List backlog items").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--limit <n>", "Maximum number of items to show").option("--sort <sort>", "Sort order: date:desc (default) | priority:desc").option("--filter <filter>", "Filter: unscored (only items without priority score)").action(async (options) => {
   await maybeRequireAuth();
   const { listBacklog: listBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
   await listBacklog2(options.chatroomId, {
     role: options.role,
-    limit: options.limit ? parseInt(options.limit, 10) : undefined
+    limit: options.limit ? parseInt(options.limit, 10) : undefined,
+    sort: options.sort,
+    filter: options.filter
   });
 });
 backlogCommand.command("add").description("Add a backlog item").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role (creator)").requiredOption("--content-file <path>", "Path to file containing task content").action(async (options) => {
@@ -16847,6 +17011,21 @@ backlogCommand.command("history").description("View completed and closed backlog
     limit: options.limit ? parseInt(options.limit, 10) : undefined
   });
 });
+backlogCommand.command("close").description("Close a backlog item (mark as stale/superseded)").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--backlog-item-id <id>", "Backlog item ID to close").requiredOption("--reason <text>", "Reason for closing (required for audit trail)").action(async (options) => {
+  await maybeRequireAuth();
+  const { closeBacklog: closeBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
+  await closeBacklog2(options.chatroomId, options);
+});
+backlogCommand.command("export").description("Export backlog items to a JSON file").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--path <path>", "Directory path to export to (default: .chatroom/exports/)").action(async (options) => {
+  await maybeRequireAuth();
+  const { exportBacklog: exportBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
+  await exportBacklog2(options.chatroomId, { role: options.role, path: options.path });
+});
+backlogCommand.command("import").description("Import backlog items from a JSON export file").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").option("--path <path>", "Directory path to import from (default: .chatroom/exports/)").action(async (options) => {
+  await maybeRequireAuth();
+  const { importBacklog: importBacklog2 } = await Promise.resolve().then(() => (init_backlog(), exports_backlog));
+  await importBacklog2(options.chatroomId, { role: options.role, path: options.path });
+});
 var taskCommand = program2.command("task").description("Manage tasks");
 taskCommand.command("read").description("Read a task and mark it as in_progress").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role in the chatroom").requiredOption("--task-id <taskId>", "Task ID to read").action(async (options) => {
   await maybeRequireAuth();