chatroom-cli 1.98.6 → 1.99.0

package/dist/index.js

@@ -83515,6 +83515,321 @@ function harnessCapabilitiesFingerprint(harnesses, versions) {
   return `${h}::${v3}`;
 }
 
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-schema.ts
+var DURABLE_FIFO_QUEUE_MIGRATIONS;
+var init_durable_fifo_queue_schema = __esm(() => {
+  DURABLE_FIFO_QUEUE_MIGRATIONS = [
+    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS fifo_outbox_entries (id INTEGER PRIMARY KEY AUTOINCREMENT, delivery_key TEXT NOT NULL, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS idx_fifo_outbox_pending ON fifo_outbox_entries(delivery_key, status, id)`
+  ];
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname9 } from "node:path";
+function openDurableFifoQueueStore(dbPath) {
+  mkdirSync4(dirname9(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
+    db.exec(sql);
+  db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
+  return {
+    enqueue: (key, payloadJson) => {
+      const now = Date.now();
+      return Number(db.prepare("INSERT INTO fifo_outbox_entries(delivery_key,payload_json,created_at,updated_at) VALUES(?,?,?,?) RETURNING id").get(key, payloadJson, now, now).id);
+    },
+    claimNextBatch: (key, limit) => db.prepare("UPDATE fifo_outbox_entries SET status='in_flight', attempts=attempts+1, updated_at=? WHERE id IN (SELECT id FROM fifo_outbox_entries WHERE delivery_key=? AND status='pending' ORDER BY id LIMIT ?) RETURNING id, delivery_key as deliveryKey, payload_json as payloadJson, attempts").all(Date.now(), key, limit),
+    markDone: (id3) => {
+      db.prepare("DELETE FROM fifo_outbox_entries WHERE id=?").run(id3);
+    },
+    markPending: (id3) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=NULL, updated_at=? WHERE id=?").run(Date.now(), id3);
+    },
+    updatePayload: (id3, payloadJson) => {
+      db.prepare("UPDATE fifo_outbox_entries SET payload_json=?, updated_at=? WHERE id=?").run(payloadJson, Date.now(), id3);
+    },
+    markPendingRetry: (id3, error) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=?, updated_at=? WHERE id=?").run(String(error), Date.now(), id3);
+    },
+    listPendingForRecovery: (key) => db.prepare("SELECT id, delivery_key as deliveryKey, payload_json as payloadJson, attempts FROM fifo_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight') ORDER BY id").all(key),
+    close: () => db.close()
+  };
+}
+var init_durable_fifo_queue_store = __esm(() => {
+  init_durable_fifo_queue_schema();
+});
+
+// src/daemon/infrastructure/outbox/lib/outbox-retry-backoff.ts
+function computeExponentialRetryDelayMs(attempt, retryDelayMs, maxRetryDelayMs) {
+  const exponent = Math.min(Math.max(0, attempt), MAX_RETRY_EXPONENT);
+  return Math.min(retryDelayMs * 2 ** exponent, maxRetryDelayMs);
+}
+var MAX_RETRY_EXPONENT = 20;
+
+// src/daemon/infrastructure/outbox/lib/fifo-batched-outbox.ts
+function createFifoBatchedOutbox(o) {
+  const waiters = new Map;
+  let running3;
+  let stopped = false;
+  let retryTimer;
+  let retryAttempt = 0;
+  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
+  const scheduleRetry = () => {
+    if (!stopped && !retryTimer) {
+      retryTimer = setTimeout(() => {
+        retryTimer = undefined;
+        drain().catch(() => {
+          return;
+        });
+      }, retryDelay());
+      retryTimer.unref?.();
+    }
+  };
+  const drain = async () => {
+    if (running3)
+      return running3;
+    running3 = (async () => {
+      while (true) {
+        const rows = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
+        if (!rows.length)
+          break;
+        try {
+          const results = await o.send(rows.map((r) => o.deserialize(r.payloadJson)));
+          let hasRetry = false;
+          for (let i2 = 0;i2 < results.length; i2++) {
+            const item = o.deserialize(rows[i2].payloadJson);
+            const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
+            if (outcome.kind === "retry") {
+              o.store.updatePayload(rows[i2].id, o.serialize(outcome.item));
+              o.store.markPending(rows[i2].id);
+              hasRetry = true;
+              continue;
+            }
+            o.store.markDone(rows[i2].id);
+            waiters.get(rows[i2].id)?.resolve(results[i2]);
+            waiters.delete(rows[i2].id);
+          }
+          for (let i2 = results.length;i2 < rows.length; i2++)
+            o.store.markPending(rows[i2].id);
+          if (hasRetry) {
+            scheduleRetry();
+            break;
+          }
+          retryAttempt = 0;
+        } catch (e) {
+          o.onError?.(e);
+          for (const r of rows)
+            o.store.markPendingRetry(r.id, e);
+          scheduleRetry();
+          break;
+        }
+      }
+    })().finally(() => {
+      running3 = undefined;
+    });
+    return running3;
+  };
+  const enqueue = (item) => {
+    if (stopped)
+      return Promise.reject(new Error("Outbox is stopped"));
+    const id3 = o.store.enqueue(o.deliveryKey, o.serialize(item));
+    const p = new Promise((resolve4, reject) => waiters.set(id3, { resolve: resolve4, reject }));
+    drain().catch(() => {
+      return;
+    });
+    return p;
+  };
+  const flushNow = async () => {
+    while (o.store.listPendingForRecovery(o.deliveryKey).length) {
+      await drain();
+    }
+  };
+  const stop4 = async () => {
+    if (stopped)
+      return;
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    retryTimer = undefined;
+    await flushNow();
+    stopped = true;
+  };
+  return { enqueue, flushNow, stop: stop4 };
+}
+var init_fifo_batched_outbox = () => {};
+
+// src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
+function createKeyedFifoBatchedOutboxRegistry(o) {
+  const boxes = new Map;
+  const get13 = (key) => {
+    let b = boxes.get(key);
+    if (!b) {
+      b = createFifoBatchedOutbox({
+        batchSize: o.batchSize,
+        send: o.createSend(key),
+        store: o.store,
+        deliveryKey: key,
+        serialize: o.serialize,
+        deserialize: o.deserialize,
+        retryDelayMs: o.retryDelayMs,
+        maxRetryDelayMs: o.maxRetryDelayMs,
+        onError: (e) => o.onError?.(key, e),
+        classifyOutcome: o.classifyOutcome
+      });
+      boxes.set(key, b);
+    }
+    return b;
+  };
+  const stop4 = async (k) => {
+    const b = boxes.get(k);
+    if (b) {
+      await b.stop();
+      boxes.delete(k);
+    }
+  };
+  return {
+    enqueue: (k, i2) => get13(k).enqueue(i2),
+    flushNow: async (k) => {
+      if (k)
+        await get13(k).flushNow();
+      else
+        for (const b of boxes.values())
+          await b.flushNow();
+    },
+    stop: stop4,
+    stopAll: async () => {
+      for (const k of [...boxes.keys()])
+        await stop4(k);
+      o.store.close();
+    }
+  };
+}
+var init_keyed_fifo_batched_outbox_registry = __esm(() => {
+  init_fifo_batched_outbox();
+});
+
+// src/daemon/infrastructure/outbox/outbox-db-path.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join17 } from "node:path";
+function resolveOutboxDbPath(machineId, kind) {
+  return join17(homedir5(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
+}
+var init_outbox_db_path = () => {};
+
+// src/daemon/domain/entities/agent-lifecycle-fact.ts
+function buildExitedLifecycleFact(auditArgs, emittedAt) {
+  const { sessionId: _sessionId, machineId: _machineId, ...fields } = auditArgs;
+  return {
+    kind: "exited",
+    ...fields,
+    revisionKey: buildAgentLifecycleRevisionKey("exited", {
+      chatroomId: auditArgs.chatroomId,
+      role: auditArgs.role,
+      pid: auditArgs.pid,
+      emittedAt
+    }),
+    emittedAt
+  };
+}
+function normalizeAgentLifecycleFact(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Invalid agent lifecycle fact");
+  }
+  const value = raw;
+  const { sessionId: _sessionId, machineId: _machineId, ...rest } = value;
+  const kind = rest.kind;
+  if (kind === "cleared_all_pids") {
+    return {
+      kind: "cleared_all_pids",
+      revisionKey: String(rest.revisionKey),
+      emittedAt: Number(rest.emittedAt)
+    };
+  }
+  if (kind === "spawned" || kind === "exited") {
+    return rest;
+  }
+  throw new Error(`Unknown agent lifecycle fact kind: ${String(kind)}`);
+}
+function agentLifecycleDeliveryKey(machineId, fact) {
+  if (fact.kind === "cleared_all_pids")
+    return `${machineId}:__machine__`;
+  return `${machineId}:${fact.chatroomId}:${fact.role.toLowerCase()}`;
+}
+function buildAgentLifecycleRevisionKey(prefix, parts2) {
+  return `${prefix}:${Object.entries(parts2).filter(([, v3]) => v3 !== undefined).map(([k, v3]) => `${k}=${v3}`).join(":")}`;
+}
+
+// src/daemon/infrastructure/outbox/agent-lifecycle-outbox.ts
+function createAgentLifecycleOutboxRegistry(machineId, createSend, options) {
+  const store = openDurableFifoQueueStore(resolveOutboxDbPath(machineId, "agent-lifecycle"));
+  return createKeyedFifoBatchedOutboxRegistry({
+    store,
+    batchSize: AGENT_LIFECYCLE_OUTBOX_BATCH_SIZE,
+    createSend: (key) => async (facts) => {
+      const results = [];
+      for (const fact of facts)
+        results.push(await createSend(key)(fact));
+      return results;
+    },
+    serialize: JSON.stringify,
+    deserialize: (serialized) => normalizeAgentLifecycleFact(JSON.parse(serialized)),
+    retryDelayMs: 500,
+    maxRetryDelayMs: 5 * 60000,
+    onError: options?.onError,
+    classifyOutcome: () => ({ kind: "success" })
+  });
+}
+function agentLifecycleKey(machineId, fact) {
+  return agentLifecycleDeliveryKey(machineId, fact);
+}
+var AGENT_LIFECYCLE_OUTBOX_BATCH_SIZE = 1;
+var init_agent_lifecycle_outbox = __esm(() => {
+  init_durable_fifo_queue_store();
+  init_keyed_fifo_batched_outbox_registry();
+  init_outbox_db_path();
+});
+
+// src/daemon/infrastructure/outbox/agent-lifecycle-send.ts
+function toConvexLifecycleFact(fact) {
+  const normalized = normalizeAgentLifecycleFact(fact);
+  if (normalized.kind === "cleared_all_pids")
+    return normalized;
+  return {
+    ...normalized,
+    chatroomId: normalized.chatroomId
+  };
+}
+function createAgentLifecycleSend(session2) {
+  return async (fact) => {
+    const args2 = {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      fact: toConvexLifecycleFact(fact)
+    };
+    return await session2.backend.mutation(api.machines.projectAgentLifecycleFact, args2);
+  };
+}
+var init_agent_lifecycle_send = __esm(() => {
+  init_api3();
+});
+
+// src/daemon/entry/agent-lifecycle-outbox-runtime.ts
+function createAgentLifecycleOutboxForSession(args2) {
+  return createAgentLifecycleOutboxRegistry(args2.machineId, () => createAgentLifecycleSend({
+    sessionId: args2.sessionId,
+    machineId: args2.machineId,
+    backend: args2.backend
+  }));
+}
+function enqueueAgentLifecycleFact(registry2, machineId, fact) {
+  return registry2.enqueue(agentLifecycleKey(machineId, fact), fact);
+}
+var init_agent_lifecycle_outbox_runtime = __esm(() => {
+  init_agent_lifecycle_outbox();
+  init_agent_lifecycle_send();
+});
+
 // src/daemon/entry/daemon-services.ts
 function DaemonMutableStateServiceLive(init2) {
   return exports_Layer.effect(DaemonMutableStateService, exports_Effect.gen(function* () {
@@ -83526,7 +83841,10 @@ function DaemonMutableStateServiceLive(init2) {
     };
   }));
 }
-var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succeed(DaemonMachineService, {
+var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, machineId) => exports_Layer.succeed(AgentLifecycleOutboxService, {
+  enqueue: (fact) => exports_Effect.promise(() => enqueueAgentLifecycleFact(registry2, machineId, fact)),
+  stopAll: () => exports_Effect.promise(() => registry2.stopAll())
+}), DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succeed(DaemonMachineService, {
   clearAgentPid: (machineId, chatroomId, role) => exports_Effect.promise(() => ops.clearAgentPid(machineId, chatroomId, role)),
   persistAgentPid: (machineId, chatroomId, role, pid, harness) => exports_Effect.promise(() => ops.persistAgentPid(machineId, chatroomId, role, pid, harness)),
   listAgentEntries: (machineId) => exports_Effect.promise(() => ops.listAgentEntries(machineId)),
@@ -83550,6 +83868,9 @@ var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succ
 }), DaemonSessionService, DaemonMutableStateService;
 var init_daemon_services = __esm(() => {
   init_esm();
+  init_agent_lifecycle_outbox_runtime();
+  AgentLifecycleOutboxService = class AgentLifecycleOutboxService extends exports_Context.Tag("AgentLifecycleOutboxService")() {
+  };
   DaemonMachineService = class DaemonMachineService extends exports_Context.Tag("DaemonMachineService")() {
   };
   DaemonSpawningService = class DaemonSpawningService extends exports_Context.Tag("DaemonSpawningService")() {
@@ -83572,7 +83893,7 @@ function daemonSessionToLayers(init2) {
   return exports_Layer.mergeAll(BackendServiceLive({
     mutation: (e, a) => init2.backend.mutation(e, a),
     query: (e, a) => init2.backend.query(e, a)
-  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager), DaemonMutableStateServiceLive({
+  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), AgentLifecycleOutboxServiceLive(init2.agentLifecycleOutbox, init2.machineId), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager), DaemonMutableStateServiceLive({
     lastPushedGitState: init2.lastPushedGitState,
     lastPushedModels: init2.lastPushedModels,
     lastPushedHarnessFingerprint: init2.lastPushedHarnessFingerprint,
@@ -83696,10 +84017,18 @@ var init_register_listeners = __esm(() => {
 
 // src/daemon/entry/handlers/daemon-restart-cleanup.ts
 var clearStaleSpawnedPidsEffect = () => exports_Effect.gen(function* () {
-  const backend2 = yield* BackendService;
+  const outbox = yield* AgentLifecycleOutboxService;
   const session2 = yield* DaemonSessionService;
-  const result = yield* backend2.mutation(api.machines.clearAllSpawnedPids, { sessionId: session2.sessionId, machineId: session2.machineId });
-  return result.clearedCount;
+  const emittedAt = Date.now();
+  const result = yield* outbox.enqueue({
+    kind: "cleared_all_pids",
+    revisionKey: buildAgentLifecycleRevisionKey("cleared_all", {
+      machineId: session2.machineId,
+      emittedAt
+    }),
+    emittedAt
+  });
+  return result.clearedCount ?? 0;
 }), reapOrphanCommandRunsEffect = () => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
   const session2 = yield* DaemonSessionService;
@@ -83737,26 +84066,26 @@ import { createHash as createHash2 } from "node:crypto";
 import {
   appendFileSync,
   existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readFileSync as readFileSync8,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join17 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { join as join18 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash2("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join17(homedir5(), ".chatroom");
-  return join17(dir, `daemon-children-${getUrlHash()}.pids`);
+  const dir = join18(homedir6(), ".chatroom");
+  return join18(dir, `daemon-children-${getUrlHash()}.pids`);
 }
 function ensureChatroomDir2() {
-  const dir = join17(homedir5(), ".chatroom");
+  const dir = join18(homedir6(), ".chatroom");
   if (!existsSync6(dir)) {
-    mkdirSync4(dir, { recursive: true, mode: 448 });
+    mkdirSync5(dir, { recursive: true, mode: 448 });
   }
 }
 function readPids() {
@@ -83869,7 +84198,7 @@ var init_orphan_tracker = __esm(() => {
 // src/daemon/entry/handlers/process/output-store.ts
 import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile6, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -83932,7 +84261,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join18(TEMP_DIR, `${runId}.log`);
+  const filePath = join19(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -83946,7 +84275,7 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join18(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join19(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
@@ -84015,7 +84344,7 @@ async function logDaemonAuditEvent(logEvent, event) {
 }
 
 // ../../services/backend/config/reliability.ts
-var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, NATIVE_DELIVERY_RECONCILE_MS = 1e4, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SYNC_RECONCILE_MS, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
+var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SYNC_RECONCILE_MS, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
 var init_reliability = __esm(() => {
   DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
   DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
@@ -98743,8 +99072,6 @@ var init_assigned_task_snapshot_contract = __esm(() => {
     assignedTo: exports_external.string().optional(),
     lastSeenAction: exports_external.string().nullable().optional(),
     lastStatus: exports_external.string().nullable().optional(),
-    spawnedAgentPid: exports_external.number().optional(),
-    desiredState: agentDesiredStateSchema.optional(),
     sessionAugmentation: sessionAugmentationSchema.optional()
   };
   assignedTaskSignalSchema = exports_external.object(assignedTaskSignalBootstrapFields);
@@ -98821,13 +99148,99 @@ function getNativeDeliveryLedger() {
 }
 var sharedLedger;
 
+// src/daemon/infrastructure/agent-operational/agent-operational-read-model.ts
+function isOperationalDesiredRunning(row) {
+  return row?.operationalState === "running" || row?.operationalState === "starting";
+}
+
+class AgentOperationalReadModel {
+  rows = new Map;
+  replace(rows) {
+    const changed = [];
+    const nextKeys = new Set;
+    for (const row of rows) {
+      const key = roleKey(row.chatroomId, row.role);
+      nextKeys.add(key);
+      const prev = this.rows.get(key);
+      if (!prev || prev.revisionKey !== row.revisionKey)
+        changed.push({ chatroomId: row.chatroomId, role: row.role });
+      this.rows.set(key, row);
+    }
+    for (const [key, prev] of this.rows) {
+      if (!nextKeys.has(key)) {
+        changed.push({ chatroomId: prev.chatroomId, role: prev.role });
+        this.rows.delete(key);
+      }
+    }
+    return changed;
+  }
+  get(chatroomId, role) {
+    return this.rows.get(roleKey(chatroomId, role));
+  }
+}
+var roleKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`;
+
+// src/daemon/infrastructure/inbox/task-snapshot-state.ts
+function snapshotKey(taskId, role) {
+  return `${taskId}:${role.toLowerCase()}`;
+}
+
+class MachineTaskSnapshotState {
+  snapshots = new Map;
+  replace(snapshots) {
+    this.snapshots.clear();
+    this.upsert(snapshots);
+  }
+  applySignalPage(signals, snapshots) {
+    const snapshotsByKey = new Map(snapshots.map((snapshot) => [
+      snapshotKey(snapshot.taskId, snapshot.agentConfig.role),
+      snapshot
+    ]));
+    for (const signal of signals) {
+      const key = snapshotKey(signal.taskId, signal.targetRole);
+      const snapshot = snapshotsByKey.get(key);
+      if (snapshot) {
+        this.snapshots.set(key, snapshot);
+      } else {
+        this.snapshots.delete(key);
+      }
+    }
+  }
+  listForRole(chatroomId, role) {
+    const roleLower = role.toLowerCase();
+    return [...this.snapshots.values()].filter((snapshot) => snapshot.chatroomId === chatroomId && snapshot.agentConfig.role.toLowerCase() === roleLower);
+  }
+  listAll() {
+    return [...this.snapshots.values()];
+  }
+  upsert(snapshots) {
+    for (const snapshot of snapshots) {
+      this.snapshots.set(snapshotKey(snapshot.taskId, snapshot.agentConfig.role), snapshot);
+    }
+  }
+}
+
+// src/daemon/entry/native-delivery/native-delivery-session-registry.ts
+function registerNativeDeliverySession(ctx) {
+  registered = {
+    ...ctx,
+    taskSnapshotState: ctx.taskSnapshotState ?? new MachineTaskSnapshotState,
+    agentOperationalReadModel: ctx.agentOperationalReadModel ?? new AgentOperationalReadModel
+  };
+}
+function unregisterNativeDeliverySession() {
+  registered = null;
+}
+function getNativeDeliverySession() {
+  return registered;
+}
+var registered = null;
+var init_native_delivery_session_registry = () => {};
+
 // src/daemon/domain/entities/assigned-task.ts
 function isDeliverableTaskStatus(status3) {
   return status3 === "pending" || status3 === "acknowledged";
 }
-function isAgentDesiredRunning(desiredState) {
-  return desiredState === "running";
-}
 var init_assigned_task = () => {};
 
 // src/daemon/domain/usecase/check-agent-slot.ts
@@ -98857,19 +99270,20 @@ function explainAgentReadyForNativeDeliveryBlock(task, slot) {
   if (!isNativeHarness(agentConfig.agentHarness)) {
     return `not_native_harness (harness=${agentConfig.agentHarness})`;
   }
-  if (!isAgentDesiredRunning(agentConfig.desiredState)) {
-    return `desired_state_not_running (desiredState=${agentConfig.desiredState})`;
-  }
-  if (agentConfig.spawnedAgentPid == null) {
-    return "spawned_pid_missing";
+  const operational = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, agentConfig.role);
+  if (!isOperationalDesiredRunning(operational)) {
+    return `operational_state_not_running (state=${operational?.operationalState ?? "missing"})`;
   }
   if (!slot) {
-    return `slot_missing (expectedPid=${agentConfig.spawnedAgentPid})`;
+    return agentConfig.spawnedAgentPid == null ? "spawned_pid_missing" : `slot_missing (expectedPid=${agentConfig.spawnedAgentPid})`;
   }
   if (!isSlotRunning(slot.state)) {
-    return `slot_not_running (slotState=${slot.state}, expectedPid=${agentConfig.spawnedAgentPid})`;
+    return `slot_not_running (slotState=${slot.state}, expectedPid=${agentConfig.spawnedAgentPid ?? "none"})`;
   }
-  if (slot.pid !== agentConfig.spawnedAgentPid) {
+  if (slot.pid == null) {
+    return "slot_pid_missing";
+  }
+  if (agentConfig.spawnedAgentPid != null && slot.pid !== agentConfig.spawnedAgentPid) {
     return `pid_mismatch (slotPid=${slot.pid ?? "none"}, snapshotPid=${agentConfig.spawnedAgentPid})`;
   }
   if (typeof slot.harnessSessionId !== "string" || slot.harnessSessionId.length === 0) {
@@ -98886,6 +99300,7 @@ function isDeliverableNativeTaskStatus(status3) {
 }
 var init_native_ready_invariant = __esm(() => {
   init_types();
+  init_native_delivery_session_registry();
   init_assigned_task();
   init_check_agent_slot();
 });
@@ -98911,18 +99326,6 @@ function logNativeDeliveryNoTasks(role, chatroomId) {
   console.log(`[NativeDelivery:skip] ${role}@${chatroomId} — no pending tasks for role`);
 }
 
-// src/daemon/entry/native-delivery/native-delivery-session-registry.ts
-function registerNativeDeliverySession(ctx) {
-  registered = ctx;
-}
-function unregisterNativeDeliverySession() {
-  registered = null;
-}
-function getNativeDeliverySession() {
-  return registered;
-}
-var registered = null;
-
 // src/daemon/entry/native-delivery/native-stale-turn-phase.ts
 function isStaleTurnInFlightWhileWaiting(task, slot) {
   if (!slot || isTurnPhaseIdle(slot.nativeTurnPhase ?? "idle"))
@@ -99409,38 +99812,21 @@ function mapAssignedTaskSnapshotList(rows) {
   return rows.map(mapAssignedTaskSnapshot);
 }
 
-// src/daemon/infrastructure/inbox/fetch-machine-assigned-task-snapshots.ts
-async function fetchMachineAssignedTaskSnapshots(sessionDeps, machineId) {
-  const result = await sessionDeps.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
-    sessionId: sessionDeps.sessionId,
-    machineId
-  });
-  return mapAssignedTaskSnapshotList(parseAssignedTaskSnapshotRows(result?.tasks ?? []));
-}
-function filterSnapshotsForRole(snapshots, chatroomId, role) {
-  const roleLower = role.toLowerCase();
-  return snapshots.filter((row) => row.chatroomId === chatroomId && row.agentConfig.role.toLowerCase() === roleLower);
-}
-var init_fetch_machine_assigned_task_snapshots = __esm(() => {
-  init_assigned_task_snapshot_contract();
-  init_api3();
-});
-
 // src/daemon/entry/restart-orchestrator-in-flight.ts
-function roleKey(chatroomId, role) {
+function roleKey2(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  inFlight.set(roleKey(chatroomId, role), correlationId);
+  inFlight.set(roleKey2(chatroomId, role), correlationId);
 }
 function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  const key = roleKey(chatroomId, role);
+  const key = roleKey2(chatroomId, role);
   if (correlationId !== undefined && inFlight.get(key) !== correlationId)
     return;
   inFlight.delete(key);
 }
 function isRestartOrchestratorInFlight(chatroomId, role) {
-  return inFlight.has(roleKey(chatroomId, role));
+  return inFlight.has(roleKey2(chatroomId, role));
 }
 function filterSnapshotsExcludingRestartInFlight(snapshots) {
   return snapshots.filter((row) => !isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role));
@@ -99451,7 +99837,7 @@ var init_restart_orchestrator_in_flight = __esm(() => {
 });
 
 // src/daemon/entry/role-delivery-state.ts
-function roleKey2(chatroomId, role) {
+function roleKey3(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 
@@ -99460,10 +99846,10 @@ class RoleDeliveryState {
   inFlight = new Set;
   nativeNudgeFailures = new Map;
   getGeneration(chatroomId, role) {
-    return this.generation.get(roleKey2(chatroomId, role)) ?? 0;
+    return this.generation.get(roleKey3(chatroomId, role)) ?? 0;
   }
   resetDeliveryState(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     const next4 = (this.generation.get(key) ?? 0) + 1;
     this.generation.set(key, next4);
     this.inFlight.delete(key);
@@ -99471,26 +99857,26 @@ class RoleDeliveryState {
     return next4;
   }
   tryAcquireDelivery(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     if (this.inFlight.has(key))
       return false;
     this.inFlight.add(key);
     return true;
   }
   releaseDelivery(chatroomId, role) {
-    this.inFlight.delete(roleKey2(chatroomId, role));
+    this.inFlight.delete(roleKey3(chatroomId, role));
   }
   recordNativeNudgeFailure(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
+    const key = roleKey3(chatroomId, role);
     const count3 = (this.nativeNudgeFailures.get(key) ?? 0) + 1;
     this.nativeNudgeFailures.set(key, count3);
     return count3;
   }
   clearNativeNudgeFailures(chatroomId, role) {
-    this.nativeNudgeFailures.delete(roleKey2(chatroomId, role));
+    this.nativeNudgeFailures.delete(roleKey3(chatroomId, role));
   }
   getNativeNudgeFailures(chatroomId, role) {
-    return this.nativeNudgeFailures.get(roleKey2(chatroomId, role)) ?? 0;
+    return this.nativeNudgeFailures.get(roleKey3(chatroomId, role)) ?? 0;
   }
 }
 function getRoleDeliveryState() {
@@ -99517,22 +99903,18 @@ class NativeTaskDeliveryCoordinator {
     if (!session2)
       return;
     const { runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = session2;
-    fetchMachineAssignedTaskSnapshots(sessionDeps, machineId).then((all8) => {
-      const tasks = filterSnapshotsForRole(all8, chatroomId, role);
-      if (tasks.length === 0) {
-        logNativeDeliveryNoTasks(role, chatroomId);
-        return;
-      }
-      this.reconcileAssignedTasks({
-        tasks,
-        runtime: runtime4,
-        effectContext: effectContext2,
-        agentMgr,
-        sessionDeps,
-        machineId
-      });
-    }).catch((err) => {
-      console.warn(`[NativeTaskDelivery] rehydrate failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`);
+    const tasks = session2.taskSnapshotState?.listForRole(chatroomId, role) ?? [];
+    if (tasks.length === 0) {
+      logNativeDeliveryNoTasks(role, chatroomId);
+      return;
+    }
+    this.reconcileAssignedTasks({
+      tasks,
+      runtime: runtime4,
+      effectContext: effectContext2,
+      agentMgr,
+      sessionDeps,
+      machineId
     });
   }
   reconcileAssignedTasks(params) {
@@ -99652,13 +100034,13 @@ function notifyNativeTurnIdle(params) {
 var coordinator;
 var init_native_task_delivery_coordinator = __esm(() => {
   init_esm();
+  init_native_delivery_session_registry();
   init_native_stale_turn_phase();
   init_native_task_injector_logic();
   init_native_task_injector();
   init_api3();
   init_assigned_task();
   init_convex_error();
-  init_fetch_machine_assigned_task_snapshots();
   init_restart_orchestrator_in_flight();
 });
 
@@ -99880,15 +100262,19 @@ var init_restart_orchestrator = __esm(() => {
 function createStartAgentDeps(agentMgr, session2) {
   return {
     agentProcessManager: {
-      ensureRunning: async (args2) => exports_Effect.runPromise(agentMgr.ensureRunning({
-        chatroomId: args2.chatroomId,
-        role: args2.role,
-        agentHarness: args2.agentHarness,
-        model: args2.model,
-        workingDir: args2.workingDir,
-        reason: args2.reason,
-        wantResume: args2.wantResume
-      }))
+      ensureRunning: async (args2) => {
+        const result = await exports_Effect.runPromise(agentMgr.ensureRunning({
+          chatroomId: args2.chatroomId,
+          role: args2.role,
+          agentHarness: args2.agentHarness,
+          model: args2.model,
+          workingDir: args2.workingDir,
+          reason: args2.reason,
+          wantResume: args2.wantResume
+        }));
+        if (!result.success) {}
+        return result;
+      }
     },
     session: {
       sessionId: session2.sessionId,
@@ -100144,9 +100530,9 @@ var init_daemon_process_scan = __esm(() => {
 
 // src/commands/machine/pid.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join20 } from "node:path";
 function getUrlHash2() {
   const url3 = getConvexUrl();
   return createHash3("sha256").update(url3).digest("hex").substring(0, 8);
@@ -100156,11 +100542,11 @@ function getPidFileName() {
 }
 function ensureChatroomDir3() {
   if (!existsSync8(CHATROOM_DIR4)) {
-    mkdirSync5(CHATROOM_DIR4, { recursive: true, mode: 448 });
+    mkdirSync6(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
-  return join19(CHATROOM_DIR4, getPidFileName());
+  return join20(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -100306,7 +100692,7 @@ var CHATROOM_DIR4, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000,
 var init_pid = __esm(() => {
   init_daemon_process_scan();
   init_client2();
-  CHATROOM_DIR4 = join19(homedir6(), ".chatroom");
+  CHATROOM_DIR4 = join20(homedir7(), ".chatroom");
 });
 
 // src/infrastructure/machine/crash-loop-tracker.ts
@@ -102052,9 +102438,8 @@ class AgentProcessManager {
       console.log(`   ⚠️  ${failureLog}: ${err.message}`);
       this.queueExitRetry({ role, args: exitArgs });
     });
-    this.deps.backend.mutation(api.daemon.agentEvents.agentExited, exitArgs).catch((err) => {
-      console.log(`   ⚠️  Failed to apply agent exit state: ${err.message}`);
-    });
+    const emittedAt = this.deps.clock.now();
+    this.deps.lifecycleOutbox.enqueue(buildExitedLifecycleFact(exitArgs, emittedAt)).catch((err) => console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`));
   }
   async clearAgentPidQuietly(chatroomId, role) {
     try {
@@ -102458,28 +102843,23 @@ class AgentProcessManager {
     }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent.started event: ${err.message}`);
     });
-    this.deps.backend.mutation(api.daemon.agentEvents.agentStarted, {
-      sessionId: this.deps.sessionId,
-      machineId: this.deps.machineId,
+    const emittedAt = this.deps.clock.now();
+    this.deps.lifecycleOutbox.enqueue({
+      kind: "spawned",
       chatroomId: opts.chatroomId,
       role: opts.role,
       pid,
       model: opts.model,
       reason: opts.reason,
-      ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {}
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to apply agent.started state: ${err.message}`);
-    });
-    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
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
-    });
+      ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {},
+      revisionKey: buildAgentLifecycleRevisionKey("spawned", {
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        pid,
+        emittedAt
+      }),
+      emittedAt
+    }).catch((err) => console.log(`   ⚠️  Failed to enqueue agent spawned lifecycle fact: ${err.message}`));
   }
   registerSpawnCallbacks(slot, opts, spawnResult, pid) {
     if (spawnResult.onLogLine) {
@@ -102834,6 +103214,11 @@ function assembleDaemonSessionInit(args2) {
   } = args2;
   deps.backend.mutation = (endpoint, args3) => client4.mutation(endpoint, args3);
   deps.backend.query = (endpoint, args3) => client4.query(endpoint, args3);
+  const agentLifecycleOutbox = createAgentLifecycleOutboxForSession({
+    sessionId: typedSessionId,
+    machineId,
+    backend: deps.backend
+  });
   deps.agentProcessManager = new AgentProcessManager({
     logEvent: activeLogEvent ?? (async () => {
       return;
@@ -102849,7 +103234,8 @@ function assembleDaemonSessionInit(args2) {
     persistence: deps.machine,
     spawning: deps.spawning,
     crashLoop: new CrashLoopTracker,
-    convexUrl
+    convexUrl,
+    lifecycleOutbox: { enqueue: (fact) => enqueueAgentLifecycleFact(agentLifecycleOutbox, machineId, fact) }
   });
   return {
     client: client4,
@@ -102862,6 +103248,7 @@ function assembleDaemonSessionInit(args2) {
     machine: deps.machine,
     spawning: deps.spawning,
     agentProcessManager: deps.agentProcessManager,
+    agentLifecycleOutbox,
     events: new DaemonEventBus,
     agentServices,
     lastPushedGitState: new Map,
@@ -103094,6 +103481,8 @@ var init_init_daemon = __esm(() => {
   init_daemon_startup_log();
   init_orphan_tracker();
   init_output_store();
+  init_agent_lifecycle_outbox_runtime();
+  init_agent_lifecycle_outbox_runtime();
   init_state_recovery();
   init_pid();
   init_storage();
@@ -105724,6 +106113,14 @@ var init_workspace_cache = __esm(() => {
 
 // src/daemon/infrastructure/git/run-command.ts
 import { spawn as spawn4 } from "node:child_process";
+function enqueueGit(cwd, task) {
+  const tail = gitQueues.get(cwd) ?? Promise.resolve();
+  const run3 = tail.then(task, task);
+  gitQueues.set(cwd, run3.catch(() => {
+    return;
+  }));
+  return run3;
+}
 function runCommandSpawn(command, args2, cwd, options) {
   const successExitCodes = options?.successExitCodes ?? [0];
   return new Promise((resolve4) => {
@@ -105769,7 +106166,7 @@ function runCommandSpawn(command, args2, cwd, options) {
   });
 }
 function runGit(args2, cwd, options) {
-  return runCommandSpawn("git", args2, cwd, options);
+  return enqueueGit(cwd, () => runCommandSpawn("git", options?.readOnly ? ["--no-optional-locks", ...args2] : args2, cwd, options));
 }
 function runGh(args2, cwd, options) {
   return runCommandSpawn("gh", args2, cwd, {
@@ -105777,7 +106174,7 @@ function runGh(args2, cwd, options) {
     env: { ...process.env, NO_COLOR: "1" }
   });
 }
-var DEFAULT_GIT_ENV;
+var DEFAULT_GIT_ENV, gitQueues;
 var init_run_command = __esm(() => {
   DEFAULT_GIT_ENV = {
     ...process.env,
@@ -105785,6 +106182,7 @@ var init_run_command = __esm(() => {
     GIT_PAGER: "cat",
     NO_COLOR: "1"
   };
+  gitQueues = new Map;
 });
 
 // src/daemon/infrastructure/git/types.ts
@@ -105794,6 +106192,9 @@ function makeGitStateKey(machineId, workingDir) {
 var FULL_DIFF_MAX_BYTES = 500000, COMMITS_PER_PAGE = 20;
 
 // src/daemon/infrastructure/git/git-reader.ts
+function runGit2(args2, cwd, options) {
+  return runGit(cwd ? args2 : args2, cwd, { ...options, readOnly: true });
+}
 function repoArgs(repoSlug) {
   return repoSlug ? ["--repo", repoSlug] : [];
 }
@@ -105810,14 +106211,14 @@ 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");
 }
 async function listUntrackedFiles(workingDir) {
-  const result = await runGit(["ls-files", "--others", "--exclude-standard"], workingDir);
+  const result = await runGit2(["ls-files", "--others", "--exclude-standard"], workingDir);
   if ("error" in result)
     return [];
   return result.stdout.split(`
 `).map((line) => line.trim()).filter(Boolean);
 }
 async function getUntrackedFileDiff(workingDir, filePath) {
-  const result = await runGit(["diff", "--no-index", "--", NULL_DEVICE, filePath], workingDir, {
+  const result = await runGit2(["diff", "--no-index", "--", NULL_DEVICE, filePath], workingDir, {
     successExitCodes: [0, 1]
   });
   if ("error" in result)
@@ -105878,7 +106279,7 @@ function truncateDiffContent(raw) {
   return { status: "available", content: raw, truncated: false };
 }
 async function runTrackedHeadDiff(workingDir, args2, options) {
-  const result = await runGit(args2, workingDir, options);
+  const result = await runGit2(args2, workingDir, options);
   if ("error" in result) {
     const errMsg = result.error.message;
     if (isEmptyRepo(errMsg))
@@ -105907,13 +106308,13 @@ function classifyError(errMessage) {
   return { status: "error", message: errMessage.trim() };
 }
 async function isGitRepo(workingDir) {
-  const result = await runGit(["rev-parse", "--git-dir"], workingDir);
+  const result = await runGit2(["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);
+  const result = await runGit2(["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")) {
@@ -105928,7 +106329,7 @@ async function getBranch(workingDir) {
   return { status: "available", branch };
 }
 async function isDirty(workingDir) {
-  const result = await runGit(["status", "--porcelain"], workingDir);
+  const result = await runGit2(["status", "--porcelain"], workingDir);
   if ("error" in result)
     return false;
   return result.stdout.trim().length > 0;
@@ -105998,7 +106399,7 @@ async function getRecentCommits(workingDir, count3 = 20, skip = 0) {
   if (skip > 0)
     logArgs.push(`--skip=${skip}`);
   logArgs.push(`--format=${format4}`);
-  const result = await runGit(logArgs, workingDir);
+  const result = await runGit2(logArgs, workingDir);
   if ("error" in result) {
     return [];
   }
@@ -106020,7 +106421,7 @@ async function getRecentCommits(workingDir, count3 = 20, skip = 0) {
   return commits;
 }
 async function getCommitDetail(workingDir, sha) {
-  const result = await runGit(["show", sha, "--format=", "--stat", "-p"], workingDir);
+  const result = await runGit2(["show", sha, "--format=", "--stat", "-p"], workingDir);
   if ("error" in result) {
     const errMsg = result.error.message;
     const classified = classifyError(errMsg);
@@ -106041,7 +106442,7 @@ async function getCommitDetail(workingDir, sha) {
 }
 async function getCommitMetadata(workingDir, sha) {
   const format4 = "%s%x1f%b%x1f%an%x1f%aI";
-  const result = await runGit(["log", "-1", `--format=${format4}`, sha], workingDir);
+  const result = await runGit2(["log", "-1", `--format=${format4}`, sha], workingDir);
   if ("error" in result)
     return null;
   const output = result.stdout.trim();
@@ -106067,7 +106468,7 @@ function parseRepoSlug(remoteUrl) {
   return null;
 }
 async function getOriginRepoSlug(cwd) {
-  const result = await runGit(["remote", "get-url", "origin"], cwd);
+  const result = await runGit2(["remote", "get-url", "origin"], cwd);
   if ("error" in result)
     return null;
   const url3 = result.stdout.trim();
@@ -106204,7 +106605,7 @@ async function getPRCommits(cwd, prNumber) {
   }
 }
 async function getRemotes(cwd) {
-  const result = await runGit(["remote", "-v"], cwd);
+  const result = await runGit2(["remote", "-v"], cwd);
   if ("error" in result)
     return [];
   if (!result.stdout.trim())
@@ -106228,14 +106629,14 @@ async function getRemotes(cwd) {
   return remotes;
 }
 async function getCommitsAhead(workingDir) {
-  const result = await runGit(["rev-list", "--count", "@{upstream}..HEAD"], workingDir);
+  const result = await runGit2(["rev-list", "--count", "@{upstream}..HEAD"], workingDir);
   if ("error" in result)
     return 0;
   const count3 = parseInt(result.stdout.trim(), 10);
   return Number.isNaN(count3) ? 0 : count3;
 }
 async function getCommitsBehind(workingDir) {
-  const result = await runGit(["rev-list", "--count", "HEAD..@{upstream}"], workingDir);
+  const result = await runGit2(["rev-list", "--count", "HEAD..@{upstream}"], workingDir);
   if ("error" in result)
     return 0;
   const count3 = parseInt(result.stdout.trim(), 10);
@@ -106329,16 +106730,12 @@ class GitStatePipeline {
     const results = new Map(preCollected);
     if (this.fields.length === 0)
       return results;
-    const entries2 = await Promise.all(this.fields.filter((f) => !results.has(f.key)).map(async (field) => {
+    for (const field of this.fields.filter((f) => !results.has(f.key))) {
       try {
-        const raw = await field.collect(workingDir);
-        return { key: field.key, raw };
+        results.set(field.key, await field.collect(workingDir));
       } catch {
-        return { key: field.key, raw: field.defaultValue };
+        results.set(field.key, field.defaultValue);
       }
-    }));
-    for (const { key, raw } of entries2) {
-      results.set(key, raw);
     }
     return results;
   }
@@ -107503,16 +107900,16 @@ var init_jsonc = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile7, readdir, stat as stat3 } from "node:fs/promises";
-import { join as join20, basename, resolve as resolve4 } from "node:path";
+import { join as join21, basename, resolve as resolve4 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join20(rootDir, cleaned.slice(0, -2));
+  const parentDir = join21(rootDir, cleaned.slice(0, -2));
   try {
     const entries2 = await readdir(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join20(parentDir, entry.name);
+      const dirPath = join21(parentDir, entry.name);
       if (resolve4(dirPath).startsWith(resolve4(rootDir))) {
         dirs.push(dirPath);
       }
@@ -107523,7 +107920,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join20(rootDir, cleaned);
+  const dir = join21(rootDir, cleaned);
   try {
     if (!resolve4(dir).startsWith(resolve4(rootDir)))
       return [];
@@ -107543,7 +107940,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile7(join20(dir, "package.json"), "utf-8");
+    const content = await readFile7(join21(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -107555,7 +107952,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join20(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile7(join21(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -107582,7 +107979,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join20(rootDir, "package.json"), "utf-8");
+    const content = await readFile7(join21(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -107663,11 +108060,11 @@ var MAX_NAME_LENGTH = 256;
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2, readFile as readFile8 } from "node:fs/promises";
-import { join as join21, relative, basename as basename2 } from "node:path";
+import { join as join22, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join21(workingDir, file2));
+      await access2(join22(workingDir, file2));
       return manager;
     } catch {}
   }
@@ -107736,7 +108133,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
   let rootPackageName = basename2(workingDir);
-  const pkg = await readJsonFile(join21(workingDir, "package.json"), "root package.json");
+  const pkg = await readJsonFile(join22(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -107752,7 +108149,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join21(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join22(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -107765,7 +108162,7 @@ async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
 async function readDenoJson(workingDir) {
   const commands = [];
   for (const fileName of ["deno.json", "deno.jsonc"]) {
-    const deno = await readJsonFile(join21(workingDir, fileName), fileName);
+    const deno = await readJsonFile(join22(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
     const pkgName = deno.name ?? basename2(workingDir);
@@ -107788,7 +108185,7 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile8(join21(workingDir, fileName), "utf-8");
+      const content = await readFile8(join22(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
@@ -109994,7 +110391,7 @@ var init_assert_registered_working_dir = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath } from "node:fs/promises";
-import { dirname as dirname9, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
+import { dirname as dirname10, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -110022,7 +110419,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname9(candidate);
+  let current = dirname10(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath(current);
@@ -110040,7 +110437,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname9(current);
+      const parent = dirname10(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -110851,16 +111248,16 @@ var require_ignore = __commonJS((exports, module) => {
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import path3 from "node:path";
 function normalizeRelativePath(relativePath) {
   return relativePath.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+$/, "");
 }
 function expandUserPath(filePath) {
   if (filePath === "~")
-    return homedir7();
+    return homedir8();
   if (filePath.startsWith("~/"))
-    return path3.join(homedir7(), filePath.slice(2));
+    return path3.join(homedir8(), filePath.slice(2));
   return filePath;
 }
 function readExcludesFileFromGitconfig(content) {
@@ -110891,11 +111288,11 @@ async function readGitconfigExcludesFilePath(configPath) {
   return path3.isAbsolute(raw) ? expandUserPath(raw) : path3.resolve(path3.dirname(configPath), raw);
 }
 async function resolveGitExtraExcludeFilePaths(rootDir) {
-  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir7(), ".gitconfig");
+  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir8(), ".gitconfig");
   const localConfig = path3.join(rootDir, ".git", "config");
   let excludesFile = await readGitconfigExcludesFilePath(localConfig) ?? await readGitconfigExcludesFilePath(globalConfig2);
   if (!excludesFile) {
-    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir7(), ".config"), "git", "ignore");
+    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir8(), ".config"), "git", "ignore");
   }
   const candidates = [excludesFile, path3.join(rootDir, ".git", "info", "exclude")];
   const existing = [];
@@ -111347,7 +111744,8 @@ function porcelainUntrackedDeletedEvents(args2) {
 }
 async function readGitHead(workTree) {
   const result = await runGit(["rev-parse", "HEAD"], workTree, {
-    timeout: GIT_POLL_TIMEOUT_MS
+    timeout: GIT_POLL_TIMEOUT_MS,
+    readOnly: true
   });
   if ("error" in result) {
     if (isEmptyRepoHeadError(result.error))
@@ -111371,7 +111769,10 @@ async function readGitPorcelainStatus(node) {
   const args2 = ["status", "--porcelain=v1", "-z", "-uall", "--"];
   if (node.pathspec.length > 0)
     args2.push(...node.pathspec);
-  const result = await runGit(args2, node.workTree, { timeout: GIT_POLL_TIMEOUT_MS });
+  const result = await runGit(args2, node.workTree, {
+    timeout: GIT_POLL_TIMEOUT_MS,
+    readOnly: true
+  });
   if ("error" in result) {
     throw new GitWorkspaceCommandError({
       operation: "readGitPorcelainStatus",
@@ -111509,35 +111910,31 @@ function createGitWorkspaceChangeSource(options) {
     let needsReconcile = false;
     let tickHadFailure = false;
     let maxNodeFailures = 0;
-    const results = await Promise.allSettled(nodes.map(async (node) => {
-      const prev = state.get(node.workTree) ?? {
-        prevEntries: [],
-        prevHead: { head: null },
-        baselineEstablished: false
-      };
-      const result = await pollGitWorkspaceNode({
-        options,
-        node,
-        prev
-      });
-      allEvents.push(...result.events);
-      if (result.needsReconcile)
-        needsReconcile = true;
-      state.set(node.workTree, result.nextState);
-      nodeFailureCounts.set(node.workTree, 0);
-      return node;
-    }));
-    for (let i2 = 0;i2 < results.length; i2++) {
-      const result = results[i2];
-      const node = nodes[i2];
-      if (!node || result.status === "fulfilled")
-        continue;
-      tickHadFailure = true;
-      options.onError?.(result.reason);
-      const prevFailures = nodeFailureCounts.get(node.workTree) ?? 0;
-      const nextFailures = prevFailures + 1;
-      nodeFailureCounts.set(node.workTree, nextFailures);
-      maxNodeFailures = Math.max(maxNodeFailures, nextFailures);
+    for (const node of nodes) {
+      try {
+        const prev = state.get(node.workTree) ?? {
+          prevEntries: [],
+          prevHead: { head: null },
+          baselineEstablished: false
+        };
+        const result = await pollGitWorkspaceNode({
+          options,
+          node,
+          prev
+        });
+        allEvents.push(...result.events);
+        if (result.needsReconcile)
+          needsReconcile = true;
+        state.set(node.workTree, result.nextState);
+        nodeFailureCounts.set(node.workTree, 0);
+      } catch (reason) {
+        tickHadFailure = true;
+        options.onError?.(reason);
+        const prevFailures = nodeFailureCounts.get(node.workTree) ?? 0;
+        const nextFailures = prevFailures + 1;
+        nodeFailureCounts.set(node.workTree, nextFailures);
+        maxNodeFailures = Math.max(maxNodeFailures, nextFailures);
+      }
     }
     if (tickHadFailure) {
       consecutiveFailureTicks += 1;
@@ -111595,7 +111992,7 @@ function createGitWorkspaceChangeSource(options) {
     }
   };
 }
-var DEFAULT_POLL_INTERVAL_MS = 1000, MAX_BACKOFF_MS = 30000, PERSISTENT_FAILURE_THRESHOLD = 3;
+var DEFAULT_POLL_INTERVAL_MS = 3000, MAX_BACKOFF_MS = 30000, PERSISTENT_FAILURE_THRESHOLD = 3;
 var init_git_workspace_change_source = __esm(() => {
   init_git_workspace_porcelain();
 });
@@ -112024,9 +112421,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname11 = sp.dirname(file2);
+    const dirname12 = sp.dirname(file2);
     const basename4 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname11);
+    const parent = this.fsw._getWatchedDir(dirname12);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -112053,7 +112450,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname11, basename4);
+          this.fsw._remove(dirname12, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -113442,8 +113839,8 @@ function diffPathIndexes(previous, next4) {
 // src/infrastructure/services/workspace/workspace-sync-state.ts
 import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join25 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -113457,10 +113854,10 @@ function buildPathIndex(entries2) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join24(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join25(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir(filePath) {
-  await fs11.mkdir(join24(filePath, ".."), { recursive: true, mode: 448 });
+  await fs11.mkdir(join25(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
@@ -113520,7 +113917,7 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join24(homedir8(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join25(homedir9(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
@@ -113897,12 +114294,12 @@ var init_durable_coalescing_state_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
-import { mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function openDurableCoalescingStateStore(path8) {
-  mkdirSync6(dirname12(path8), { recursive: true });
-  const db = new DatabaseSync(path8);
+  mkdirSync7(dirname13(path8), { recursive: true });
+  const db = new DatabaseSync2(path8);
   for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
     db.exec(sql);
   db.prepare("UPDATE coalescing_outbox_entries SET status='pending' WHERE status='in_flight'").run();
@@ -113919,13 +114316,6 @@ var init_durable_coalescing_state_store = __esm(() => {
   init_durable_coalescing_state_schema();
 });
 
-// src/daemon/infrastructure/outbox/lib/outbox-retry-backoff.ts
-function computeExponentialRetryDelayMs(attempt, retryDelayMs, maxRetryDelayMs) {
-  const exponent = Math.min(Math.max(0, attempt), MAX_RETRY_EXPONENT);
-  return Math.min(retryDelayMs * 2 ** exponent, maxRetryDelayMs);
-}
-var MAX_RETRY_EXPONENT = 20;
-
 // src/daemon/infrastructure/outbox/lib/coalescing-state-outbox.ts
 function createCoalescingStateOutbox(options) {
   const durable = [options.store, options.deliveryKey, options.serialize, options.deserialize];
@@ -114102,14 +114492,6 @@ var init_keyed_coalescing_state_outbox_registry = __esm(() => {
   init_coalescing_state_outbox();
 });
 
-// src/daemon/infrastructure/outbox/outbox-db-path.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join25 } from "node:path";
-function resolveOutboxDbPath(machineId, kind) {
-  return join25(homedir9(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
-}
-var init_outbox_db_path = () => {};
-
 // src/daemon/infrastructure/outbox/workspace-file-tree-checkpoint-outbox.ts
 function createWorkspaceFileTreeCheckpointOutboxRegistry(machineId, createSend, options) {
   return createKeyedCoalescingStateOutboxRegistry({
@@ -114131,193 +114513,6 @@ var init_workspace_file_tree_checkpoint_outbox = __esm(() => {
   WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MAX_RETRY_DELAY_MS = 5 * 60000;
 });
 
-// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-schema.ts
-var DURABLE_FIFO_QUEUE_MIGRATIONS;
-var init_durable_fifo_queue_schema = __esm(() => {
-  DURABLE_FIFO_QUEUE_MIGRATIONS = [
-    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
-    `CREATE TABLE IF NOT EXISTS fifo_outbox_entries (id INTEGER PRIMARY KEY AUTOINCREMENT, delivery_key TEXT NOT NULL, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
-    `CREATE INDEX IF NOT EXISTS idx_fifo_outbox_pending ON fifo_outbox_entries(delivery_key, status, id)`
-  ];
-});
-
-// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
-function openDurableFifoQueueStore(dbPath) {
-  mkdirSync7(dirname13(dbPath), { recursive: true });
-  const db = new DatabaseSync2(dbPath);
-  for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
-    db.exec(sql);
-  db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
-  return {
-    enqueue: (key, payloadJson) => {
-      const now = Date.now();
-      return Number(db.prepare("INSERT INTO fifo_outbox_entries(delivery_key,payload_json,created_at,updated_at) VALUES(?,?,?,?) RETURNING id").get(key, payloadJson, now, now).id);
-    },
-    claimNextBatch: (key, limit) => db.prepare("UPDATE fifo_outbox_entries SET status='in_flight', attempts=attempts+1, updated_at=? WHERE id IN (SELECT id FROM fifo_outbox_entries WHERE delivery_key=? AND status='pending' ORDER BY id LIMIT ?) RETURNING id, delivery_key as deliveryKey, payload_json as payloadJson, attempts").all(Date.now(), key, limit),
-    markDone: (id3) => {
-      db.prepare("DELETE FROM fifo_outbox_entries WHERE id=?").run(id3);
-    },
-    markPending: (id3) => {
-      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=NULL, updated_at=? WHERE id=?").run(Date.now(), id3);
-    },
-    updatePayload: (id3, payloadJson) => {
-      db.prepare("UPDATE fifo_outbox_entries SET payload_json=?, updated_at=? WHERE id=?").run(payloadJson, Date.now(), id3);
-    },
-    markPendingRetry: (id3, error51) => {
-      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=?, updated_at=? WHERE id=?").run(String(error51), Date.now(), id3);
-    },
-    listPendingForRecovery: (key) => db.prepare("SELECT id, delivery_key as deliveryKey, payload_json as payloadJson, attempts FROM fifo_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight') ORDER BY id").all(key),
-    close: () => db.close()
-  };
-}
-var init_durable_fifo_queue_store = __esm(() => {
-  init_durable_fifo_queue_schema();
-});
-
-// src/daemon/infrastructure/outbox/lib/fifo-batched-outbox.ts
-function createFifoBatchedOutbox(o) {
-  const waiters = new Map;
-  let running3;
-  let stopped = false;
-  let retryTimer;
-  let retryAttempt = 0;
-  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
-  const scheduleRetry = () => {
-    if (!stopped && !retryTimer) {
-      retryTimer = setTimeout(() => {
-        retryTimer = undefined;
-        drain2().catch(() => {
-          return;
-        });
-      }, retryDelay());
-      retryTimer.unref?.();
-    }
-  };
-  const drain2 = async () => {
-    if (running3)
-      return running3;
-    running3 = (async () => {
-      while (true) {
-        const rows = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
-        if (!rows.length)
-          break;
-        try {
-          const results = await o.send(rows.map((r) => o.deserialize(r.payloadJson)));
-          let hasRetry = false;
-          for (let i2 = 0;i2 < results.length; i2++) {
-            const item = o.deserialize(rows[i2].payloadJson);
-            const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
-            if (outcome.kind === "retry") {
-              o.store.updatePayload(rows[i2].id, o.serialize(outcome.item));
-              o.store.markPending(rows[i2].id);
-              hasRetry = true;
-              continue;
-            }
-            o.store.markDone(rows[i2].id);
-            waiters.get(rows[i2].id)?.resolve(results[i2]);
-            waiters.delete(rows[i2].id);
-          }
-          for (let i2 = results.length;i2 < rows.length; i2++)
-            o.store.markPending(rows[i2].id);
-          if (hasRetry) {
-            scheduleRetry();
-            break;
-          }
-          retryAttempt = 0;
-        } catch (e) {
-          o.onError?.(e);
-          for (const r of rows)
-            o.store.markPendingRetry(r.id, e);
-          scheduleRetry();
-          break;
-        }
-      }
-    })().finally(() => {
-      running3 = undefined;
-    });
-    return running3;
-  };
-  const enqueue = (item) => {
-    if (stopped)
-      return Promise.reject(new Error("Outbox is stopped"));
-    const id3 = o.store.enqueue(o.deliveryKey, o.serialize(item));
-    const p = new Promise((resolve8, reject) => waiters.set(id3, { resolve: resolve8, reject }));
-    drain2().catch(() => {
-      return;
-    });
-    return p;
-  };
-  const flushNow = async () => {
-    while (o.store.listPendingForRecovery(o.deliveryKey).length) {
-      await drain2();
-    }
-  };
-  const stop4 = async () => {
-    if (stopped)
-      return;
-    if (retryTimer)
-      clearTimeout(retryTimer);
-    retryTimer = undefined;
-    await flushNow();
-    stopped = true;
-  };
-  return { enqueue, flushNow, stop: stop4 };
-}
-var init_fifo_batched_outbox = () => {};
-
-// src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
-function createKeyedFifoBatchedOutboxRegistry(o) {
-  const boxes = new Map;
-  const get13 = (key) => {
-    let b = boxes.get(key);
-    if (!b) {
-      b = createFifoBatchedOutbox({
-        batchSize: o.batchSize,
-        send: o.createSend(key),
-        store: o.store,
-        deliveryKey: key,
-        serialize: o.serialize,
-        deserialize: o.deserialize,
-        retryDelayMs: o.retryDelayMs,
-        maxRetryDelayMs: o.maxRetryDelayMs,
-        onError: (e) => o.onError?.(key, e),
-        classifyOutcome: o.classifyOutcome
-      });
-      boxes.set(key, b);
-    }
-    return b;
-  };
-  const stop4 = async (k) => {
-    const b = boxes.get(k);
-    if (b) {
-      await b.stop();
-      boxes.delete(k);
-    }
-  };
-  return {
-    enqueue: (k, i2) => get13(k).enqueue(i2),
-    flushNow: async (k) => {
-      if (k)
-        await get13(k).flushNow();
-      else
-        for (const b of boxes.values())
-          await b.flushNow();
-    },
-    stop: stop4,
-    stopAll: async () => {
-      for (const k of [...boxes.keys()])
-        await stop4(k);
-      o.store.close();
-    }
-  };
-}
-var init_keyed_fifo_batched_outbox_registry = __esm(() => {
-  init_fifo_batched_outbox();
-});
-
 // src/daemon/infrastructure/outbox/workspace-file-tree-delta-outbox.ts
 function createWorkspaceFileTreeDeltaOutboxRegistry(machineId, createSend, options) {
   const store = openDurableFifoQueueStore(resolveOutboxDbPath(machineId, "file-tree-delta"));
@@ -114352,6 +114547,8 @@ var init_workspace_file_tree_delta_outbox = __esm(() => {
 var init_outbox = __esm(() => {
   init_workspace_file_tree_checkpoint_outbox();
   init_workspace_file_tree_delta_outbox();
+  init_agent_lifecycle_outbox();
+  init_agent_lifecycle_send();
 });
 
 // ../../services/backend/src/domain/workspace-file-tree/types.ts
@@ -115760,7 +115957,8 @@ var init_command_run_subscription = __esm(() => {
 // src/daemon/entry/task-delivery/task-delivery-logic.ts
 function isPendingAliveRunningTask(task) {
   const { agentConfig, status: status3 } = task;
-  return status3 === "pending" && agentConfig.spawnedAgentPid != null && isAgentDesiredRunning(agentConfig.desiredState);
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, agentConfig.role);
+  return status3 === "pending" && (agentConfig.spawnedAgentPid != null || op?.isAlive === true) && isOperationalDesiredRunning(op);
 }
 function isSlotUnavailableForPid(slot, pid, isPidAlive, now = Date.now()) {
   if (!slot) {
@@ -115783,7 +115981,7 @@ function isSlotUnavailableForPid(slot, pid, isPidAlive, now = Date.now()) {
 function isNativeRevivableTaskStatus(task) {
   const { status: status3 } = task;
   if (status3 === "pending") {
-    return task.agentConfig.spawnedAgentPid != null;
+    return true;
   }
   if (status3 === "acknowledged") {
     return task.assignedTo?.toLowerCase() === task.agentConfig.role.toLowerCase();
@@ -115803,7 +116001,8 @@ function isNativeAgentSlotDown(task, health, now = Date.now()) {
 function isNativeActiveTaskAgentDown(task, health, now) {
   if (!isNativeHarness(task.agentConfig.agentHarness))
     return false;
-  if (!isAgentDesiredRunning(task.agentConfig.desiredState))
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
+  if (!isOperationalDesiredRunning(op))
     return false;
   if (!isNativeRevivableTaskStatus(task))
     return false;
@@ -115827,7 +116026,8 @@ function isNativePendingTaskNeedingWake(task) {
     return false;
   if (task.status !== "pending")
     return false;
-  if (isAgentDesiredRunning(task.agentConfig.desiredState))
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
+  if (isOperationalDesiredRunning(op))
     return false;
   return Boolean(task.agentConfig.workingDir);
 }
@@ -115903,10 +116103,10 @@ function listTasksReadyForNudge(tasks, now, cooldown, getSlot) {
 }
 var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000;
 var init_task_delivery_logic = __esm(() => {
-  init_assigned_task();
   init_check_agent_slot();
   init_predicates();
   init_agent_process_manager();
+  init_native_delivery_session_registry();
   init_native_ready_invariant();
   init_native_task_injector_logic();
 });
@@ -116006,7 +116206,7 @@ function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
-  console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — desiredState=stopped with pending task ${task.taskId}`);
+  console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — operational_state=stopped with pending task ${task.taskId}`);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.ensureRunning({
       chatroomId,
@@ -116072,7 +116272,7 @@ async function wakeStoppedAgentsForPendingTasks(tasks, now, cooldown, runtime4,
   }
 }
 async function processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, machineId, _pass, options) {
-  const tasks = options?.snapshots ? [...options.snapshots] : await fetchMachineAssignedTaskSnapshots(sessionDeps, machineId);
+  const tasks = [...options.snapshots];
   const filteredTasks = filterSnapshotsExcludingRestartInFlight(tasks);
   if (filteredTasks.length === 0)
     return;
@@ -116104,11 +116304,48 @@ var init_task_delivery_processor = __esm(() => {
   init_native_task_injector_logic();
   init_api3();
   init_convex_error();
-  init_fetch_machine_assigned_task_snapshots();
   init_restart_orchestrator_in_flight();
   init_task_delivery_logic();
 });
 
+// src/daemon/infrastructure/agent-operational/enrich-snapshot-with-operational.ts
+function enrichSnapshotWithOperational(snapshot) {
+  const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(snapshot.chatroomId, snapshot.agentConfig.role);
+  if (!op)
+    return snapshot;
+  return { ...snapshot, agentConfig: { ...snapshot.agentConfig, desiredState: isOperationalDesiredRunning(op) ? "running" : "stopped" } };
+}
+function enrichSnapshotsWithOperational(snapshots) {
+  return snapshots.map(enrichSnapshotWithOperational);
+}
+var init_enrich_snapshot_with_operational = __esm(() => {
+  init_native_delivery_session_registry();
+});
+
+// src/daemon/infrastructure/agent-operational/subscribe-machine-agent-operational-status.ts
+function subscribeMachineAgentOperationalStatus(client4, options, onRows) {
+  return client4.onUpdate(api.machines.subscribeMachineAgentOperationalStatus, { sessionId: options.sessionId, machineId: options.machineId }, (result) => {
+    if (Array.isArray(result))
+      onRows(result);
+  });
+}
+var init_subscribe_machine_agent_operational_status = __esm(() => {
+  init_api3();
+});
+
+// src/daemon/infrastructure/inbox/fetch-machine-assigned-task-snapshots.ts
+async function fetchMachineAssignedTaskSnapshots(sessionDeps, machineId) {
+  const result = await sessionDeps.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
+    sessionId: sessionDeps.sessionId,
+    machineId
+  });
+  return mapAssignedTaskSnapshotList(parseAssignedTaskSnapshotRows(result?.tasks ?? []));
+}
+var init_fetch_machine_assigned_task_snapshots = __esm(() => {
+  init_assigned_task_snapshot_contract();
+  init_api3();
+});
+
 // src/daemon/infrastructure/inbox/store/schema.ts
 var SCHEMA_VERSION = 1, MIGRATIONS;
 var init_schema = __esm(() => {
@@ -116261,12 +116498,16 @@ var init_inbox = __esm(() => {
 
 // src/daemon/infrastructure/inbox/task-inbox-delivery.ts
 async function handleTaskInboxUpdate(update6, deps) {
+  const taskSnapshotState = deps.taskSnapshotState ?? getNativeDeliverySession()?.taskSnapshotState;
+  taskSnapshotState?.applySignalPage(update6.signals, update6.snapshots);
   if (update6.snapshots.length === 0)
     return;
-  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "inbox-signal");
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "inbox-signal", { snapshots: enrichSnapshotsWithOperational(update6.snapshots) });
 }
 var init_task_inbox_delivery = __esm(() => {
+  init_native_delivery_session_registry();
   init_task_delivery_processor();
+  init_enrich_snapshot_with_operational();
 });
 
 // src/daemon/infrastructure/inbox/task.ts
@@ -116376,14 +116617,19 @@ var init_task = __esm(() => {
 
 // src/daemon/entry/task-inbox-runtime.ts
 async function bootstrapMachineAssignedTaskSnapshots(deps) {
+  await deps.sessionDeps.backend.mutation(api.machines.backfillAgentOperationalStatusForMachine, {
+    sessionId: deps.sessionDeps.sessionId,
+    machineId: deps.machineId
+  });
   await deps.sessionDeps.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
     sessionId: deps.sessionDeps.sessionId,
     machineId: deps.machineId
   });
   const tasks = await fetchMachineAssignedTaskSnapshots(deps.sessionDeps, deps.machineId);
+  deps.taskSnapshotState?.replace(tasks);
   if (!tasks.length)
     return;
-  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: tasks });
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: enrichSnapshotsWithOperational(tasks) });
 }
 function isAbortError(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
@@ -116403,7 +116649,7 @@ async function runInboxLoopWithRestart(options, onUpdate, isStopped) {
     }
   }
 }
-var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
+var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
   const effectContext2 = yield* exports_Effect.context();
@@ -116426,14 +116672,20 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
   });
   const abort = new AbortController;
   let stopped = false;
+  const taskSnapshotState = new MachineTaskSnapshotState;
+  const agentOperationalReadModel = new AgentOperationalReadModel;
   registerNativeDeliverySession({
     runtime: runtime4,
     effectContext: effectContext2,
     agentMgr,
     sessionDeps,
-    machineId: session2.machineId
+    machineId: session2.machineId,
+    taskSnapshotState,
+    agentOperationalReadModel
   });
   const cooldown = new RecoveryCooldown;
+  let inboxUpdateInFlight = false;
+  let reconcileInFlight = false;
   const inboxOptions = {
     client: wsClient2,
     sessionId: session2.sessionId,
@@ -116443,36 +116695,62 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
     signal: abort.signal
   };
   const inboxHandler = async (update6) => {
-    await handleTaskInboxUpdate(update6, {
-      runtime: runtime4,
-      effectContext: effectContext2,
-      cooldown,
-      agentMgr,
-      sessionDeps,
-      machineId: session2.machineId
-    });
-    inboxStore.save({ inboxType: "task", scopeKey: session2.machineId }, { afterSignalKey: update6.throughSignalKey });
+    inboxUpdateInFlight = true;
+    try {
+      await handleTaskInboxUpdate(update6, {
+        runtime: runtime4,
+        effectContext: effectContext2,
+        cooldown,
+        agentMgr,
+        sessionDeps,
+        machineId: session2.machineId,
+        taskSnapshotState
+      });
+      inboxStore.save({ inboxType: "task", scopeKey: session2.machineId }, { afterSignalKey: update6.throughSignalKey });
+    } finally {
+      inboxUpdateInFlight = false;
+    }
   };
-  const reconcileTimer = setInterval(() => {
-    if (stopped)
-      return;
-    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile");
-  }, NATIVE_DELIVERY_RECONCILE_MS);
   yield* exports_Effect.tryPromise(() => bootstrapMachineAssignedTaskSnapshots({
     sessionDeps,
     runtime: runtime4,
     effectContext: effectContext2,
     cooldown,
     agentMgr,
-    machineId: session2.machineId
+    machineId: session2.machineId,
+    taskSnapshotState
   })).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[TaskInbox] bootstrap failed:", error51);
     return exports_Effect.void;
   }));
+  const unsubscribeOperational = subscribeMachineAgentOperationalStatus(wsClient2, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    signal: abort.signal
+  }, (rows) => {
+    if (stopped)
+      return;
+    const changed = agentOperationalReadModel.replace(rows);
+    const snapshots = changed.flatMap(({ chatroomId, role }) => taskSnapshotState.listForRole(chatroomId, role));
+    if (snapshots.length === 0)
+      return;
+    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "operational-status", { snapshots: enrichSnapshotsWithOperational(snapshots) }).catch((error51) => console.warn("[TaskInbox] operational-status reconcile failed:", error51));
+  }) ?? (() => {});
+  const reconcileTimer = setInterval(() => {
+    if (stopped || inboxUpdateInFlight || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: enrichSnapshotsWithOperational(taskSnapshotState.listAll()) }).catch((error51) => {
+      console.warn("[TaskInbox] local delivery reconciliation failed:", error51);
+    }).finally(() => {
+      reconcileInFlight = false;
+    });
+  }, NATIVE_DELIVERY_RECONCILE_MS);
   runInboxLoopWithRestart(inboxOptions, inboxHandler, () => stopped);
   return {
     stop() {
       stopped = true;
+      unsubscribeOperational();
       abort.abort();
       clearInterval(reconcileTimer);
       unregisterNativeDeliverySession();
@@ -116481,12 +116759,14 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
   };
 });
 var init_task_inbox_runtime = __esm(() => {
-  init_reliability();
   init_esm();
   init_daemon_services();
   init_api3();
+  init_native_delivery_session_registry();
   init_task_delivery_processor();
   init_task_delivery_logic();
+  init_enrich_snapshot_with_operational();
+  init_subscribe_machine_agent_operational_status();
   init_fetch_machine_assigned_task_snapshots();
   init_inbox();
   init_task_inbox_delivery();
@@ -116944,6 +117224,9 @@ function createDaemonRuntime(deps) {
     shutdownWatchdog.unref?.();
     if (heartbeatTimer)
       clearInterval(heartbeatTimer);
+    await deps.agentLifecycleOutbox?.stopAll().catch(() => {
+      return;
+    });
     stopWorkers();
     await withTimeout2(exports_Effect.runPromise(exports_Effect.gen(function* () {
       const effectContext2 = yield* exports_Effect.context();
@@ -118163,10 +118446,10 @@ function startWorkspaceListSubscriber(deps, onEvent) {
   const unsub = deps.wsClient.onUpdate(api.workspaces.listRecentlyObservedWorkspacesForMachine, queryArgs, (workspaces) => {
     if (workspaces == null)
       return;
-    const snapshotKey = JSON.stringify(workspaces);
-    if (snapshotKey === lastSnapshotKey)
+    const snapshotKey2 = JSON.stringify(workspaces);
+    if (snapshotKey2 === lastSnapshotKey)
       return;
-    lastSnapshotKey = snapshotKey;
+    lastSnapshotKey = snapshotKey2;
     onEvent({ type: "workspace.list-changed", machineId: deps.machineId });
   }, (err) => {
     console.warn(`[daemon] workspace-list subscriber error: ${err instanceof Error ? err.message : String(err)}`);
@@ -132765,7 +133048,11 @@ async function startDaemon() {
   console.log(`[daemon] Local web UI: http://127.0.0.1:${localWeb.port}/`);
   const layers = daemonSessionToLayers(init2);
   startBackgroundMachineCapabilitiesDiscovery(createStartBackgroundCapabilitiesDiscoveryDeps(layers));
-  const runtime4 = createDaemonRuntime({ wsClient: wsClient2, layers });
+  const runtime4 = createDaemonRuntime({
+    wsClient: wsClient2,
+    layers,
+    agentLifecycleOutbox: init2.agentLifecycleOutbox
+  });
   try {
     await runtime4.run();
   } finally {
@@ -134010,4 +134297,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=654C294BE572C9D764756E2164756E21
+//# debugId=D5DF842800E395EE64756E2164756E21