chatroom-cli 1.98.5 → 1.98.7

package/dist/index.js

@@ -83544,7 +83544,9 @@ var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succ
   clearStuckStoppingSlot: (chatroomId, role) => exports_Effect.promise(() => mgr.clearStuckStoppingSlot(chatroomId, role)),
   whenTurnEndsIdle: () => exports_Effect.promise(() => mgr.whenTurnEndsIdle()),
   resumeTurnForSlot: (args2) => exports_Effect.promise(() => mgr.resumeTurnForSlot(args2)),
-  setLastInFlightTask: (chatroomId, role, taskId) => exports_Effect.sync(() => mgr.setLastInFlightTask(chatroomId, role, taskId))
+  setLastInFlightTask: (chatroomId, role, taskId) => exports_Effect.sync(() => mgr.setLastInFlightTask(chatroomId, role, taskId)),
+  clearLastInFlightTaskIfMatches: (chatroomId, role, taskId) => exports_Effect.sync(() => mgr.clearLastInFlightTaskIfMatches(chatroomId, role, taskId)),
+  reconcileNativeTurnPhaseIdle: (chatroomId, role) => exports_Effect.sync(() => mgr.reconcileNativeTurnPhaseIdle(chatroomId, role))
 }), DaemonSessionService, DaemonMutableStateService;
 var init_daemon_services = __esm(() => {
   init_esm();
@@ -84012,8 +84014,76 @@ async function logDaemonAuditEvent(logEvent, event) {
   });
 }
 
+// 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()];
+  }
+  setDesiredState(chatroomId, role, desiredState) {
+    const roleLower = role.toLowerCase();
+    for (const [key, snapshot] of this.snapshots) {
+      if (snapshot.chatroomId !== chatroomId || snapshot.agentConfig.role.toLowerCase() !== roleLower) {
+        continue;
+      }
+      this.snapshots.set(key, {
+        ...snapshot,
+        agentConfig: { ...snapshot.agentConfig, desiredState }
+      });
+    }
+  }
+  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
+  };
+}
+function unregisterNativeDeliverySession() {
+  registered = null;
+}
+function getNativeDeliverySession() {
+  return registered;
+}
+var registered = null;
+var init_native_delivery_session_registry = () => {};
+
 // ../../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;
@@ -98686,40 +98756,18 @@ var init_convex_id = __esm(() => {
   init_zod();
 });
 
-// ../../services/backend/src/domain/usecase/machine/assigned-task-monitor-contract.ts
-function parseAssignedTaskSignal(raw) {
-  return assignedTaskSignalSchema.parse(raw);
+// ../../services/backend/src/domain/usecase/machine/assigned-task-snapshot-contract.ts
+function parseAssignedTaskSnapshotRow(raw) {
+  return assignedTaskSnapshotRowSchema.parse(raw);
 }
-function parseAssignedTaskPresenceSignal(raw) {
-  const full = assignedTaskPresenceSignalSchema.safeParse(raw);
-  if (full.success)
-    return full.data;
-  const delta = assignedTaskPresenceDeltaSchema.safeParse(raw);
-  if (delta.success) {
-    const presenceUpdatedAt = Number(delta.data.presenceKey.split(":")[0]);
-    const resolvedAt = Number.isFinite(presenceUpdatedAt) ? presenceUpdatedAt : 0;
-    return {
-      taskId: delta.data.taskId,
-      chatroomId: "",
-      role: delta.data.role,
-      lastSeenAt: resolvedAt,
-      presenceUpdatedAt: resolvedAt,
-      presenceKey: delta.data.presenceKey
-    };
-  }
-  return assignedTaskPresenceSignalSchema.parse(raw);
-}
-function parseAssignedTaskMonitorRow(raw) {
-  return assignedTaskMonitorRowSchema.parse(raw);
-}
-function parseAssignedTaskMonitorRows(raw) {
+function parseAssignedTaskSnapshotRows(raw) {
   if (!Array.isArray(raw)) {
     throw new Error("Expected hydrate tasks array");
   }
-  return raw.map((row) => parseAssignedTaskMonitorRow(row));
+  return raw.map((row) => parseAssignedTaskSnapshotRow(row));
 }
-var ACTIVE_TASK_STATUSES, activeTaskStatusSchema, ASSIGNED_TASK_SIGNAL_TYPES, assignedTaskSignalTypeSchema, SESSION_AUGMENTATION_MODES, sessionAugmentationSchema, AGENT_DESIRED_STATES, agentDesiredStateSchema, AGENT_CIRCUIT_STATES, agentCircuitStateSchema, chatroomTaskIdSchema, chatroomRoomIdSchema, assignedTaskAgentConfigSchema, assignedTaskParticipantSchema, assignedTaskSignalBootstrapFields, assignedTaskSignalSchema, assignedTaskPresenceSignalSchema, assignedTaskPresenceDeltaSchema, assignedTaskMonitorRowSchema;
-var init_assigned_task_monitor_contract = __esm(() => {
+var ACTIVE_TASK_STATUSES, activeTaskStatusSchema, ASSIGNED_TASK_SIGNAL_TYPES, assignedTaskSignalTypeSchema, SESSION_AUGMENTATION_MODES, sessionAugmentationSchema, AGENT_DESIRED_STATES, agentDesiredStateSchema, AGENT_CIRCUIT_STATES, agentCircuitStateSchema, chatroomTaskIdSchema, chatroomRoomIdSchema, assignedTaskAgentConfigSchema, assignedTaskParticipantSchema, assignedTaskSignalBootstrapFields, assignedTaskSignalSchema, assignedTaskPresenceSignalSchema, assignedTaskPresenceDeltaSchema, assignedTaskSnapshotRowSchema;
+var init_assigned_task_snapshot_contract = __esm(() => {
   init_zod();
   init_convex_id();
   ACTIVE_TASK_STATUSES = ["pending", "acknowledged", "in_progress"];
@@ -98782,7 +98830,7 @@ var init_assigned_task_monitor_contract = __esm(() => {
     role: exports_external.string(),
     presenceKey: exports_external.string()
   });
-  assignedTaskMonitorRowSchema = exports_external.object({
+  assignedTaskSnapshotRowSchema = exports_external.object({
     taskId: chatroomTaskIdSchema,
     chatroomId: chatroomRoomIdSchema,
     status: activeTaskStatusSchema,
@@ -98880,16 +98928,16 @@ function explainAgentReadyForNativeDeliveryBlock(task, slot) {
   if (!isAgentDesiredRunning(agentConfig.desiredState)) {
     return `desired_state_not_running (desiredState=${agentConfig.desiredState})`;
   }
-  if (agentConfig.spawnedAgentPid == null) {
-    return "spawned_pid_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) {
@@ -98931,17 +98979,18 @@ 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;
+// src/daemon/entry/native-delivery/native-stale-turn-phase.ts
+function isStaleTurnInFlightWhileWaiting(task, slot) {
+  if (!slot || isTurnPhaseIdle(slot.nativeTurnPhase ?? "idle"))
+    return false;
+  if (task.status !== "pending")
+    return false;
+  return task.participant?.lastSeenAction === NATIVE_WAITING_ACTION;
 }
-var registered = null;
+var init_native_stale_turn_phase = __esm(() => {
+  init_participant();
+  init_check_agent_slot();
+});
 
 // src/daemon/domain/native-integration/predicates.ts
 function isStaleCliGetNextTaskWaiting(task) {
@@ -99002,8 +99051,21 @@ function explainNativeDeliveryBlock(task, opts) {
       return `acknowledged_wrong_role (assignedTo=${assignedTo ?? "none"}, role=${role})`;
     }
   }
+  const inFlightBlock = explainInFlightDeliveryBlock(task, opts.slot);
+  if (inFlightBlock)
+    return inFlightBlock;
   return explainAgentReadyForNativeDeliveryBlock(task, opts.slot);
 }
+function explainInFlightDeliveryBlock(task, slot) {
+  if (!slot?.lastInFlightTaskId || slot.lastInFlightTaskId !== task.taskId)
+    return null;
+  if (task.status === "pending")
+    return null;
+  if (task.status === "acknowledged") {
+    return "already_delivered_to_slot (lastInFlightTaskId match, status=acknowledged)";
+  }
+  return null;
+}
 function explainLedgerDeliveryBlock(taskId, harnessSessionId, ledger) {
   if (ledger.isDelivered(taskId, harnessSessionId)) {
     return "already_delivered_this_session";
@@ -99403,30 +99465,6 @@ function mapAssignedTaskSnapshotList(rows) {
   return rows.map(mapAssignedTaskSnapshot);
 }
 
-// src/infrastructure/stores/assigned-task-snapshot-store.ts
-function replaceAssignedTaskSnapshots(next4) {
-  rows = [...next4];
-  hasSnapshot = true;
-}
-function clearAssignedTaskSnapshots() {
-  rows = [];
-  hasSnapshot = false;
-}
-function hasAssignedTaskSnapshot() {
-  return hasSnapshot;
-}
-function listAssignedTaskSnapshots() {
-  return [...rows];
-}
-function listAssignedTaskSnapshotsForRole(chatroomId, role) {
-  const roleLower = role.toLowerCase();
-  return rows.filter((row) => row.chatroomId === chatroomId && row.agentConfig.role.toLowerCase() === roleLower);
-}
-var rows, hasSnapshot = false;
-var init_assigned_task_snapshot_store = __esm(() => {
-  rows = [];
-});
-
 // src/daemon/entry/restart-orchestrator-in-flight.ts
 function roleKey(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
@@ -99518,7 +99556,7 @@ class NativeTaskDeliveryCoordinator {
     if (!session2)
       return;
     const { runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps, machineId } = session2;
-    const tasks = listAssignedTaskSnapshotsForRole(chatroomId, role);
+    const tasks = session2.taskSnapshotState?.listForRole(chatroomId, role) ?? [];
     if (tasks.length === 0) {
       logNativeDeliveryNoTasks(role, chatroomId);
       return;
@@ -99549,7 +99587,18 @@ class NativeTaskDeliveryCoordinator {
     for (const row of pendingFirst) {
       const { role } = row.agentConfig;
       const slot = agentMgr.getSlot(row.chatroomId, role);
-      const blockReason = explainNativeDeliveryBlock(row, { slot });
+      if (row.status === "pending" && slot?.lastInFlightTaskId === row.taskId) {
+        exports_Effect.runSync(agentMgr.clearLastInFlightTaskIfMatches(row.chatroomId, role, row.taskId));
+      }
+      if (isStaleTurnInFlightWhileWaiting(row, slot)) {
+        if (agentMgr.reconcileNativeTurnPhaseIdle) {
+          exports_Effect.runSync(agentMgr.reconcileNativeTurnPhaseIdle(row.chatroomId, role));
+        }
+        logNativeDeliveryFallback("stale-turn-phase", role, row.chatroomId, row.taskId);
+      }
+      const blockReason = explainNativeDeliveryBlock(row, {
+        slot: agentMgr.getSlot(row.chatroomId, role)
+      });
       if (blockReason) {
         if (isDeliverableTaskStatus(row.status)) {
           logNativeDeliverySkip(role, row.chatroomId, row.taskId, blockReason);
@@ -99638,11 +99687,12 @@ 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_assigned_task_snapshot_store();
   init_convex_error();
   init_restart_orchestrator_in_flight();
 });
@@ -99718,7 +99768,7 @@ async function listDeliverableSnapshots(deps, event) {
     machineId: deps.session.machineId
   });
   const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
-  return mapAssignedTaskSnapshotList(parseAssignedTaskMonitorRows(result.tasks ?? [])).filter((t) => t.chatroomId === event.chatroomId && t.agentConfig.role.toLowerCase() === event.role.toLowerCase() && isDeliverableTaskStatus(t.status) && isAgentReadyForNativeDelivery(t, slot)).sort((a, b) => a.createdAt - b.createdAt);
+  return mapAssignedTaskSnapshotList(parseAssignedTaskSnapshotRows(result.tasks ?? [])).filter((t) => t.chatroomId === event.chatroomId && t.agentConfig.role.toLowerCase() === event.role.toLowerCase() && isDeliverableTaskStatus(t.status) && isAgentReadyForNativeDelivery(t, slot)).sort((a, b) => a.createdAt - b.createdAt);
 }
 async function deliverOneTask(deps, event, snapshot) {
   const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
@@ -99740,6 +99790,11 @@ async function deliverOneTask(deps, event, snapshot) {
     console.warn(`[RestartOrchestrator] skip task ${snapshot.taskId} — ${ledgerBlock}`);
     return false;
   }
+  const deliveryBlock = explainNativeDeliveryBlock(snapshot, { slot });
+  if (deliveryBlock) {
+    console.warn(`[RestartOrchestrator] skip task ${snapshot.taskId} — ${deliveryBlock}`);
+    return false;
+  }
   if (!ledger.tryAcquire(snapshot.taskId, harnessSessionId)) {
     console.warn(`[RestartOrchestrator] skip task ${snapshot.taskId} — delivery_ledger_busy`);
     return false;
@@ -99843,7 +99898,7 @@ var init_restart_orchestrator = __esm(() => {
   init_reliability();
   init_participant();
   init_build_agent_restart_event();
-  init_assigned_task_monitor_contract();
+  init_assigned_task_snapshot_contract();
   init_esm();
   init_api3();
   init_native_ready_invariant();
@@ -99860,15 +99915,23 @@ 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 taskSnapshotState = getNativeDeliverySession()?.taskSnapshotState;
+        taskSnapshotState?.setDesiredState(args2.chatroomId, args2.role, "running");
+        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) {
+          taskSnapshotState?.setDesiredState(args2.chatroomId, args2.role, "stopped");
+        }
+        return result;
+      }
     },
     session: {
       sessionId: session2.sessionId,
@@ -99989,6 +100052,7 @@ function createRecoverAgentStateDeps(agentMgr, session2) {
 var init_agent_control_bridge = __esm(() => {
   init_esm();
   init_api3();
+  init_native_delivery_session_registry();
   init_restart_orchestrator();
 });
 
@@ -101527,6 +101591,7 @@ class AgentProcessManager {
       }
       if (slot) {
         setNativeTurnPhase(slot, defaultNativeTurnPhase());
+        this.clearLastInFlightTask(opts.chatroomId, opts.role);
       }
       notifyNativeTurnIdle({ chatroomId: opts.chatroomId, role: opts.role });
       console.log(`[AgentProcessManager] ✅ Native agent_end handled for ${opts.role}`);
@@ -101542,6 +101607,9 @@ class AgentProcessManager {
     }
     const stopReason = resolveStopReason(opts.code, opts.signal);
     const ctx = this.captureExitContext(slot, opts, stopReason);
+    if (slot.harness && getHarnessCapabilities(slot.harness).supportsNativeIntegration) {
+      setNativeTurnPhase(slot, defaultNativeTurnPhase());
+    }
     this.maybeEmitProviderUnavailable(opts.chatroomId, opts.role, slot);
     notifyNativeHarnessSessionLostOnExit({
       chatroomId: opts.chatroomId,
@@ -101843,6 +101911,21 @@ class AgentProcessManager {
     const slot = this.getOrCreateSlot(agentKey3(chatroomId, role));
     slot.lastInFlightTaskId = taskId;
   }
+  clearLastInFlightTaskIfMatches(chatroomId, role, taskId) {
+    const slot = this.slots.get(agentKey3(chatroomId, role));
+    if (slot?.lastInFlightTaskId === taskId)
+      slot.lastInFlightTaskId = undefined;
+  }
+  reconcileNativeTurnPhaseIdle(chatroomId, role) {
+    const slot = this.getSlot(chatroomId, role);
+    if (slot)
+      setNativeTurnPhase(slot, defaultNativeTurnPhase());
+  }
+  clearLastInFlightTask(chatroomId, role) {
+    const slot = this.slots.get(agentKey3(chatroomId, role));
+    if (slot)
+      slot.lastInFlightTaskId = undefined;
+  }
   listActive() {
     const result = [];
     for (const [key, slot] of this.slots) {
@@ -102512,6 +102595,9 @@ class AgentProcessManager {
       setNativeTurnPhase(slot, defaultNativeTurnPhase());
     }
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
+    if (getHarnessCapabilities(opts.agentHarness).supportsNativeIntegration) {
+      getNativeTaskDeliveryCoordinator().tryInjectNextForRole(opts.chatroomId, opts.role);
+    }
   }
   async emitNativeWaiting(chatroomId, role, harness) {
     return emitNativeWaitingAfterSpawn({
@@ -114159,27 +114245,27 @@ function createFifoBatchedOutbox(o) {
       return running3;
     running3 = (async () => {
       while (true) {
-        const rows2 = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
-        if (!rows2.length)
+        const rows = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
+        if (!rows.length)
           break;
         try {
-          const results = await o.send(rows2.map((r) => o.deserialize(r.payloadJson)));
+          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(rows2[i2].payloadJson);
+            const item = o.deserialize(rows[i2].payloadJson);
             const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
             if (outcome.kind === "retry") {
-              o.store.updatePayload(rows2[i2].id, o.serialize(outcome.item));
-              o.store.markPending(rows2[i2].id);
+              o.store.updatePayload(rows[i2].id, o.serialize(outcome.item));
+              o.store.markPending(rows[i2].id);
               hasRetry = true;
               continue;
             }
-            o.store.markDone(rows2[i2].id);
-            waiters.get(rows2[i2].id)?.resolve(results[i2]);
-            waiters.delete(rows2[i2].id);
+            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 < rows2.length; i2++)
-            o.store.markPending(rows2[i2].id);
+          for (let i2 = results.length;i2 < rows.length; i2++)
+            o.store.markPending(rows[i2].id);
           if (hasRetry) {
             scheduleRetry();
             break;
@@ -114187,7 +114273,7 @@ function createFifoBatchedOutbox(o) {
           retryAttempt = 0;
         } catch (e) {
           o.onError?.(e);
-          for (const r of rows2)
+          for (const r of rows)
             o.store.markPendingRetry(r.id, e);
           scheduleRetry();
           break;
@@ -115715,20 +115801,7 @@ var init_command_run_subscription = __esm(() => {
   dispatchedStop = new Set;
 });
 
-// src/daemon/entry/assigned-task-monitor-registry.ts
-function registerAssignedTaskMonitorHandler(h) {
-  handler6 = h;
-}
-function unregisterAssignedTaskMonitorHandler() {
-  handler6 = undefined;
-}
-async function dispatchAssignedTaskMonitorEvent(event) {
-  if (handler6)
-    await handler6(event);
-}
-var handler6;
-
-// src/daemon/entry/task-monitor/task-monitor-logic.ts
+// 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);
@@ -115754,7 +115827,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();
@@ -115787,9 +115860,29 @@ function listNativeTasksNeedingRevive(tasks, health, now, cooldown) {
     const { chatroomId, agentConfig } = task;
     if (!agentConfig.workingDir)
       return false;
-    if (!cooldown.canNudge(chatroomId, agentConfig.role, now))
+    if (!cooldown.canAttempt(chatroomId, agentConfig.role, "revive", now))
+      return false;
+    cooldown.recordAttempt(chatroomId, agentConfig.role, "revive", now);
+    return true;
+  });
+}
+function isNativePendingTaskNeedingWake(task) {
+  if (!isNativeHarness(task.agentConfig.agentHarness))
+    return false;
+  if (task.status !== "pending")
+    return false;
+  if (isAgentDesiredRunning(task.agentConfig.desiredState))
+    return false;
+  return Boolean(task.agentConfig.workingDir);
+}
+function listNativePendingTasksNeedingWake(tasks, cooldown, now) {
+  return tasks.filter((task) => {
+    if (!isNativePendingTaskNeedingWake(task))
+      return false;
+    const { chatroomId, agentConfig } = task;
+    if (!cooldown.canAttempt(chatroomId, agentConfig.role, "wake", now))
       return false;
-    cooldown.recordNudge(chatroomId, agentConfig.role, now);
+    cooldown.recordAttempt(chatroomId, agentConfig.role, "wake", now);
     return true;
   });
 }
@@ -115813,23 +115906,20 @@ function shouldNudgeNativePendingTask(task, now, pendingIdleThresholdMs, slot) {
   const idleSince = lastSeenAt > 0 ? now - lastSeenAt : now - task.createdAt;
   return idleSince > pendingIdleThresholdMs;
 }
-function shouldEscalateNativeNudgeToRestart(chatroomId, role, failures3) {
-  return failures3 >= NATIVE_NUDGE_ESCALATION_THRESHOLD;
-}
 
-class NudgeCooldown {
+class RecoveryCooldown {
   cooldownMs;
-  lastNudgedAt = new Map;
+  lastAttemptAt = new Map;
   constructor(cooldownMs = NUDGE_COOLDOWN_MS) {
     this.cooldownMs = cooldownMs;
   }
-  canNudge(chatroomId, role, now) {
-    const key = `${chatroomId}:${role}`;
-    const last2 = this.lastNudgedAt.get(key);
+  canAttempt(chatroomId, role, kind, now) {
+    const key = `${kind}:${chatroomId}:${role}`;
+    const last2 = this.lastAttemptAt.get(key);
     return last2 === undefined || now - last2 >= this.cooldownMs;
   }
-  recordNudge(chatroomId, role, now) {
-    this.lastNudgedAt.set(`${chatroomId}:${role}`, now);
+  recordAttempt(chatroomId, role, kind, now) {
+    this.lastAttemptAt.set(`${kind}:${chatroomId}:${role}`, now);
   }
 }
 function isTaskReadyForNudge(task, now, cooldown, getSlot) {
@@ -115841,7 +115931,7 @@ function isTaskReadyForNudge(task, now, cooldown, getSlot) {
     return false;
   }
   const { chatroomId, agentConfig } = task;
-  if (!cooldown.canNudge(chatroomId, agentConfig.role, now))
+  if (!cooldown.canAttempt(chatroomId, agentConfig.role, "nudge", now))
     return false;
   if (!agentConfig.workingDir)
     return false;
@@ -115851,12 +115941,12 @@ function listTasksReadyForNudge(tasks, now, cooldown, getSlot) {
   return tasks.filter((task) => {
     if (!isTaskReadyForNudge(task, now, cooldown, getSlot))
       return false;
-    cooldown.recordNudge(task.chatroomId, task.agentConfig.role, now);
+    cooldown.recordAttempt(task.chatroomId, task.agentConfig.role, "nudge", now);
     return true;
   });
 }
-var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000, NATIVE_NUDGE_ESCALATION_THRESHOLD = 2;
-var init_task_monitor_logic = __esm(() => {
+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();
@@ -115865,7 +115955,7 @@ var init_task_monitor_logic = __esm(() => {
   init_native_task_injector_logic();
 });
 
-// src/daemon/entry/task-monitor-runtime.ts
+// src/daemon/entry/native-delivery/task-delivery-processor.ts
 function resolveTaskWantResume(task) {
   return sessionAugmentationToWantResume(resolveSessionAugmentationForTask({ content: task.taskContent ?? "", startInNewSession: task.startInNewSession }, task.agentConfig.role));
 }
@@ -115955,6 +116045,24 @@ function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
     });
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native revive failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
+function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
+  const ctx = resolveTaskRunnerContextFromFull(task);
+  if (!ctx)
+    return;
+  const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
+  console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — desiredState=stopped with pending task ${task.taskId}`);
+  exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
+    yield* agentMgr.ensureRunning({
+      chatroomId,
+      role,
+      agentHarness: agentConfig.agentHarness,
+      model: agentConfig.model,
+      workingDir,
+      reason: "platform.pending_task_wake",
+      wantResume
+    });
+  }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native wake failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
+}
 async function fetchTaskForAction(sessionDeps, machineId, snapshotRow) {
   const result = await sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
     sessionId: sessionDeps.sessionId,
@@ -115976,43 +116084,9 @@ async function clearStuckStoppingSlotIfNeeded(agentMgr, chatroomId, role) {
 }
 async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   const getSlot = (chatroomId, role) => agentMgr.getSlot(chatroomId, role);
-  for (const row of listTasksReadyForNudge(tasks, now, cooldown, getSlot)) {
+  const cliTasks = tasks.filter((task) => !isNativeHarness(task.agentConfig.agentHarness));
+  for (const row of listTasksReadyForNudge(cliTasks, now, cooldown, getSlot)) {
     await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
-    if (isNativeHarness(row.agentConfig.agentHarness)) {
-      const { chatroomId, agentConfig } = row;
-      const { role } = agentConfig;
-      if (!isTeamAgentRole(role))
-        continue;
-      const deliveryState = getRoleDeliveryState();
-      const failures3 = deliveryState.recordNativeNudgeFailure(chatroomId, role);
-      if (shouldEscalateNativeNudgeToRestart(chatroomId, role, failures3)) {
-        const full2 = await fetchTaskForAction(sessionDeps, machineId, row);
-        if (!full2)
-          continue;
-        console.log(`[TaskMonitor] native nudge escalate restart ${role}@${chatroomId} — pending task ${row.taskId}`);
-        runCliNudgeEffect(full2, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
-        deliveryState.clearNativeNudgeFailures(chatroomId, role);
-        continue;
-      }
-      resetRoleDeliveryState(chatroomId, role);
-      await sessionDeps.backend.mutation(api.participants.join, {
-        sessionId: sessionDeps.sessionId,
-        chatroomId,
-        role,
-        action: NATIVE_WAITING_ACTION
-      });
-      console.log(`[TaskMonitor] native light nudge ${role}@${chatroomId} — redeliver pending task ${row.taskId}`);
-      logNativeDeliveryFallback("native-light-nudge", role, chatroomId, row.taskId);
-      getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
-        tasks: [row],
-        runtime: runtime4,
-        effectContext: effectContext2,
-        agentMgr,
-        sessionDeps,
-        machineId
-      });
-      continue;
-    }
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -116030,7 +116104,19 @@ async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, ef
     runNativeReviveEffect(full, runtime4, effectContext2, agentMgr);
   }
 }
-async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, machineId, _pass) {
+async function wakeStoppedAgentsForPendingTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
+  for (const row of listNativePendingTasksNeedingWake(tasks, cooldown, now)) {
+    if (isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role))
+      continue;
+    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
+    const full = await fetchTaskForAction(sessionDeps, machineId, row);
+    if (!full)
+      continue;
+    runNativeWakeEffect(full, runtime4, effectContext2, agentMgr);
+  }
+}
+async function processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, machineId, _pass, options) {
+  const tasks = [...options.snapshots];
   const filteredTasks = filterSnapshotsExcludingRestartInFlight(tasks);
   if (filteredTasks.length === 0)
     return;
@@ -116039,10 +116125,11 @@ async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, age
     getSlot: (chatroomId, role) => agentMgr.getSlot(chatroomId, role),
     isPidAlive: (pid) => isProcessAlive((p) => process.kill(p, 0), pid)
   };
+  await wakeStoppedAgentsForPendingTasks(filteredTasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   await reviveNativeTasks(filteredTasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   if (filteredTasks.length > 0) {
     const first = filteredTasks[0];
-    logNativeDeliveryFallback("signal-presence", first.agentConfig.role, first.chatroomId, first.taskId);
+    logNativeDeliveryFallback(_pass, first.agentConfig.role, first.chatroomId, first.taskId);
   }
   getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
     tasks: filteredTasks,
@@ -116054,60 +116141,333 @@ async function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, age
   });
   await nudgeStuckTasks(filteredTasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
 }
-function listDeliverablePendingFromStore(agentMgr) {
-  if (!hasAssignedTaskSnapshot())
-    return [];
-  return listAssignedTaskSnapshots().filter((row) => {
-    if (row.status !== "pending")
-      return false;
-    const slot = agentMgr.getSlot(row.chatroomId, row.agentConfig.role);
-    return isAgentReadyForNativeDelivery(row, slot);
+var init_task_delivery_processor = __esm(() => {
+  init_parse_session_augmentation();
+  init_esm();
+  init_native_task_delivery_coordinator();
+  init_native_task_injector_logic();
+  init_api3();
+  init_convex_error();
+  init_restart_orchestrator_in_flight();
+  init_task_delivery_logic();
+});
+
+// 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 runLocalStoreReconcilePass(params) {
-  const { stopped, monitorPassInFlight, agentMgr, runtime: runtime4, effectContext: effectContext2, sessionDeps, machineId } = params;
-  if (stopped || monitorPassInFlight)
-    return;
-  const deliverable = filterSnapshotsExcludingRestartInFlight(listDeliverablePendingFromStore(agentMgr));
-  if (deliverable.length === 0)
+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(() => {
+  MIGRATIONS = [
+    `CREATE TABLE IF NOT EXISTS schema_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS inbox_state (
+    inbox_type TEXT NOT NULL,
+    scope_key TEXT NOT NULL,
+    state_json TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (inbox_type, scope_key)
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_inbox_state_type_updated
+   ON inbox_state(inbox_type, updated_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_inbox_state_updated
+   ON inbox_state(updated_at DESC)`
+  ];
+});
+
+// src/daemon/infrastructure/inbox/store/open-database.ts
+import { mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname15 } from "node:path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+function openDatabase(dbPath) {
+  mkdirSync8(dirname15(dbPath), { recursive: true });
+  const db = new DatabaseSync3(dbPath);
+  for (const sql of MIGRATIONS) {
+    db.exec(sql);
+  }
+  db.prepare(`INSERT INTO schema_meta(key, value) VALUES('version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(SCHEMA_VERSION));
+  return db;
+}
+var init_open_database = __esm(() => {
+  init_schema();
+});
+
+// src/daemon/infrastructure/inbox/store/state-store.ts
+function assertKeyPart(value, name) {
+  if (value.trim().length === 0) {
+    throw new Error(`${name} cannot be empty`);
+  }
+}
+function encodeState(state) {
+  const encoded = JSON.stringify(state);
+  if (encoded === undefined) {
+    throw new Error("Inbox state must be JSON serializable");
+  }
+  return encoded;
+}
+function decodeRow(row) {
+  return {
+    inboxType: row.inbox_type,
+    scopeKey: row.scope_key,
+    state: JSON.parse(row.state_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function buildQuery(options) {
+  const clauses = [];
+  const params = [];
+  if (options.inboxType !== undefined) {
+    clauses.push("inbox_type = ?");
+    params.push(options.inboxType);
+  }
+  if (options.scopeKey !== undefined) {
+    clauses.push("scope_key = ?");
+    params.push(options.scopeKey);
+  }
+  if (options.scopePrefix !== undefined) {
+    clauses.push("scope_key LIKE ?");
+    params.push(`${options.scopePrefix}%`);
+  }
+  if (options.updatedAfter !== undefined) {
+    clauses.push("updated_at > ?");
+    params.push(options.updatedAfter);
+  }
+  const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+  const limit = Math.min(Math.max(options.limit ?? MAX_QUERY_LIMIT, 1), MAX_QUERY_LIMIT);
+  return {
+    sql: `SELECT inbox_type, scope_key, state_json, created_at, updated_at
+          FROM inbox_state ${where}
+          ORDER BY updated_at DESC, inbox_type ASC, scope_key ASC
+          LIMIT ?`,
+    params: [...params, limit]
+  };
+}
+function getInboxState(db, key) {
+  assertKeyPart(key.inboxType, "inboxType");
+  assertKeyPart(key.scopeKey, "scopeKey");
+  const row = db.prepare(`SELECT inbox_type, scope_key, state_json, created_at, updated_at
+       FROM inbox_state
+       WHERE inbox_type = ? AND scope_key = ?`).get(key.inboxType, key.scopeKey);
+  return row ? decodeRow(row) : null;
+}
+function saveInboxState(db, key, state, updatedAt = Date.now()) {
+  assertKeyPart(key.inboxType, "inboxType");
+  assertKeyPart(key.scopeKey, "scopeKey");
+  const stateJson = encodeState(state);
+  db.prepare(`INSERT INTO inbox_state(inbox_type, scope_key, state_json, created_at, updated_at)
+     VALUES(?, ?, ?, ?, ?)
+     ON CONFLICT(inbox_type, scope_key) DO UPDATE SET
+       state_json = excluded.state_json,
+       updated_at = excluded.updated_at`).run(key.inboxType, key.scopeKey, stateJson, updatedAt, updatedAt);
+}
+function queryInboxState(db, options = {}) {
+  const { sql, params } = buildQuery(options);
+  return db.prepare(sql).all(...params).map((row) => decodeRow(row));
+}
+function deleteInboxState(db, key) {
+  assertKeyPart(key.inboxType, "inboxType");
+  assertKeyPart(key.scopeKey, "scopeKey");
+  db.prepare("DELETE FROM inbox_state WHERE inbox_type = ? AND scope_key = ?").run(key.inboxType, key.scopeKey);
+}
+var MAX_QUERY_LIMIT = 1000;
+
+// src/daemon/infrastructure/inbox/store/inbox-state-store.ts
+function createInboxStateStore(dbPath) {
+  const db = openDatabase(dbPath);
+  return {
+    get: (key) => getInboxState(db, key),
+    save: (key, state, updatedAt) => saveInboxState(db, key, state, updatedAt),
+    query: (options) => queryInboxState(db, options),
+    delete: (key) => deleteInboxState(db, key),
+    close: () => db.close()
+  };
+}
+var init_inbox_state_store = __esm(() => {
+  init_open_database();
+});
+
+// src/daemon/infrastructure/inbox/store/inbox-db-path.ts
+import { homedir as homedir10 } from "node:os";
+import { join as join26 } from "node:path";
+function resolveInboxDbPath(machineId) {
+  return join26(homedir10(), ".chatroom", "daemon", machineId, "inboxes.sqlite");
+}
+var init_inbox_db_path = () => {};
+
+// src/daemon/infrastructure/inbox/index.ts
+var init_inbox = __esm(() => {
+  init_inbox_state_store();
+  init_inbox_db_path();
+});
+
+// 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;
-  const first = deliverable[0];
-  logNativeDeliveryFallback("periodic-reconcile", first.agentConfig.role, first.chatroomId, first.taskId);
-  getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
-    tasks: deliverable,
-    runtime: runtime4,
-    effectContext: effectContext2,
-    agentMgr,
-    sessionDeps,
-    machineId
-  });
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "inbox-signal", { snapshots: update6.snapshots });
+}
+var init_task_inbox_delivery = __esm(() => {
+  init_native_delivery_session_registry();
+  init_task_delivery_processor();
+});
+
+// src/daemon/infrastructure/inbox/task.ts
+function taskSignalCursorAt(timestamp) {
+  return `${String(Math.max(0, Math.floor(timestamp))).padStart(16, "0")}:`;
 }
-function subscribeAssignedTaskSnapshotStore(wsClient2, args2, isStopped) {
-  return wsClient2.onUpdate(api.machines.listMachineAssignedTaskSnapshots, args2, (result) => {
-    if (isStopped())
+function abortError() {
+  const error51 = new Error("Task inbox stopped");
+  error51.name = "AbortError";
+  return error51;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError();
+}
+function waitForTaskSignalPage(options, afterSignalKey) {
+  return new Promise((resolve8, reject) => {
+    let unsubscribe;
+    let settled = false;
+    const cleanup = () => {
+      unsubscribe?.();
+      unsubscribe = undefined;
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+    const settle2 = (fn2) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      fn2();
+    };
+    const onAbort = () => {
+      settle2(() => reject(abortError()));
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      throwIfAborted(options.signal);
+    } catch (error51) {
+      settle2(() => reject(error51));
       return;
-    const tasks = mapAssignedTaskSnapshotList(parseAssignedTaskMonitorRows(result?.tasks ?? []));
-    replaceAssignedTaskSnapshots(tasks);
-  }, (err) => {
-    console.warn(`[${formatTimestamp()}] ⚠️  Assigned-task snapshot subscription error: ${getErrorMessage(err)}`);
+    }
+    unsubscribe = options.client.onUpdate(api.messageList.subscribeTaskStatusSignalsSince, {
+      sessionId: options.sessionId,
+      machineId: options.machineId,
+      afterKey: afterSignalKey,
+      limit: options.signalPageLimit ?? DEFAULT_SIGNAL_PAGE_LIMIT
+    }, (result) => {
+      if (!result || typeof result !== "object")
+        return;
+      const page = result;
+      const items = page.items;
+      const highKey = page.highKey;
+      if (!items?.length || !highKey)
+        return;
+      settle2(() => resolve8({
+        items,
+        afterSignalKey,
+        highSignalKey: highKey
+      }));
+    }, (error51) => {
+      settle2(() => reject(error51));
+    });
   });
 }
-function handleInboundAssignedTaskEvent(event, runMonitorPass) {
-  const row = listAssignedTaskSnapshots().find((snapshot) => snapshot.taskId === event.taskId && snapshot.agentConfig.role === event.role);
-  if (!row)
+async function* createTaskSignalIterator(options) {
+  let afterSignalKey = options.initialAfterSignalKey ?? taskSignalCursorAt(options.serviceStartedAt ?? Date.now());
+  while (!options.signal?.aborted) {
+    const page = await waitForTaskSignalPage(options, afterSignalKey);
+    yield page;
+    afterSignalKey = page.highSignalKey;
+  }
+}
+async function fetchSnapshotsForSignalPage(options, page) {
+  const snapshots = [];
+  let afterSignalKey = page.afterSignalKey;
+  while (true) {
+    throwIfAborted(options.signal);
+    const result = await options.client.query(api.tasks.listTasksForMachineSignalRange, {
+      sessionId: options.sessionId,
+      machineId: options.machineId,
+      afterSignalKey,
+      throughSignalKey: page.highSignalKey,
+      limit: options.taskPageLimit ?? DEFAULT_TASK_PAGE_LIMIT
+    });
+    snapshots.push(...result.snapshots);
+    if (!result.hasMore || !result.nextSignalKey)
+      break;
+    afterSignalKey = result.nextSignalKey;
+  }
+  return snapshots;
+}
+async function runTaskInbox(options, onUpdate) {
+  for await (const page of createTaskSignalIterator(options)) {
+    const snapshots = await fetchSnapshotsForSignalPage(options, page);
+    await onUpdate({
+      signals: page.items,
+      snapshots,
+      afterSignalKey: page.afterSignalKey,
+      throughSignalKey: page.highSignalKey
+    });
+  }
+}
+var DEFAULT_SIGNAL_PAGE_LIMIT = 100, DEFAULT_TASK_PAGE_LIMIT = 500;
+var init_task = __esm(() => {
+  init_api3();
+});
+
+// src/daemon/entry/task-inbox-runtime.ts
+async function bootstrapMachineAssignedTaskSnapshots(deps) {
+  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;
-  const pass = event.type === "assigned-task.signal" ? "signal" : "presence";
-  runMonitorPass([row], pass);
+  await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: tasks });
 }
-var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
+function isAbortError(error51) {
+  return error51 instanceof Error && error51.name === "AbortError";
+}
+async function runInboxLoopWithRestart(options, onUpdate, isStopped) {
+  let backoffMs = INBOX_RESTART_INITIAL_MS;
+  while (!isStopped()) {
+    try {
+      await runTaskInbox(options, onUpdate);
+      return;
+    } catch (error51) {
+      if (isStopped() || isAbortError(error51))
+        return;
+      console.warn(`[TaskInbox] loop error, restarting in ${backoffMs}ms:`, error51);
+      await new Promise((resolve8) => setTimeout(resolve8, backoffMs));
+      backoffMs = Math.min(backoffMs * 2, INBOX_RESTART_MAX_MS);
+    }
+  }
+}
+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();
   const runtime4 = yield* exports_Effect.runtime();
-  console.log(`[${formatTimestamp()}] \uD83D\uDCCB Starting task-monitor (incremental subscribe)`);
-  const cooldown = new NudgeCooldown;
-  let stopped = false;
-  let monitorPassInFlight = false;
   const sessionDeps = {
     sessionId: session2.sessionId,
     convexUrl: session2.convexUrl,
@@ -116118,68 +116478,95 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
       query: (fn2, args2) => session2.backend.query(fn2, args2)
     }
   };
+  console.log(`[${formatTimestamp()}] \uD83D\uDCEC Starting task-inbox (machine-scoped signals)`);
+  const inboxStore = createInboxStateStore(resolveInboxDbPath(session2.machineId));
+  const persisted = inboxStore.get({
+    inboxType: "task",
+    scopeKey: session2.machineId
+  });
+  const abort = new AbortController;
+  let stopped = false;
+  const taskSnapshotState = new MachineTaskSnapshotState;
   registerNativeDeliverySession({
     runtime: runtime4,
     effectContext: effectContext2,
     agentMgr,
     sessionDeps,
-    machineId: session2.machineId
+    machineId: session2.machineId,
+    taskSnapshotState
   });
-  const unsubscribeSnapshotStore = subscribeAssignedTaskSnapshotStore(wsClient2, { sessionId: session2.sessionId, machineId: session2.machineId }, () => stopped);
-  const runMonitorPass = (tasks, pass) => {
-    if (stopped || monitorPassInFlight || tasks.length === 0)
-      return;
-    monitorPassInFlight = true;
-    processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, pass).finally(() => {
-      monitorPassInFlight = false;
-    });
+  const cooldown = new RecoveryCooldown;
+  let inboxUpdateInFlight = false;
+  let reconcileInFlight = false;
+  const inboxOptions = {
+    client: wsClient2,
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    serviceStartedAt: Date.now(),
+    initialAfterSignalKey: persisted?.state.afterSignalKey,
+    signal: abort.signal
   };
-  registerAssignedTaskMonitorHandler(async (event) => {
-    handleInboundAssignedTaskEvent(event, runMonitorPass);
-  });
+  const inboxHandler = async (update6) => {
+    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;
+    }
+  };
+  yield* exports_Effect.tryPromise(() => bootstrapMachineAssignedTaskSnapshots({
+    sessionDeps,
+    runtime: runtime4,
+    effectContext: effectContext2,
+    cooldown,
+    agentMgr,
+    machineId: session2.machineId,
+    taskSnapshotState
+  })).pipe(exports_Effect.catchAll((error51) => {
+    console.warn("[TaskInbox] bootstrap failed:", error51);
+    return exports_Effect.void;
+  }));
   const reconcileTimer = setInterval(() => {
-    runLocalStoreReconcilePass({
-      stopped,
-      monitorPassInFlight,
-      agentMgr,
-      runtime: runtime4,
-      effectContext: effectContext2,
-      sessionDeps,
-      machineId: session2.machineId
+    if (stopped || inboxUpdateInFlight || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: taskSnapshotState.listAll() }).catch((error51) => {
+      console.warn("[TaskInbox] local delivery reconciliation failed:", error51);
+    }).finally(() => {
+      reconcileInFlight = false;
     });
   }, NATIVE_DELIVERY_RECONCILE_MS);
-  yield* exports_Effect.tryPromise(() => session2.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId
-  })).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+  runInboxLoopWithRestart(inboxOptions, inboxHandler, () => stopped);
   return {
     stop() {
       stopped = true;
-      unregisterAssignedTaskMonitorHandler();
-      unsubscribeSnapshotStore();
-      clearAssignedTaskSnapshots();
-      unregisterNativeDeliverySession();
+      abort.abort();
       clearInterval(reconcileTimer);
-      console.log(`[${formatTimestamp()}] \uD83D\uDCCB Task-monitor stopped`);
+      unregisterNativeDeliverySession();
+      inboxStore.close();
     }
   };
 });
-var init_task_monitor_runtime = __esm(() => {
-  init_reliability();
-  init_participant();
-  init_parse_session_augmentation();
-  init_assigned_task_monitor_contract();
+var init_task_inbox_runtime = __esm(() => {
   init_esm();
   init_daemon_services();
-  init_native_ready_invariant();
-  init_native_task_delivery_coordinator();
-  init_native_task_injector_logic();
-  init_restart_orchestrator_in_flight();
-  init_task_monitor_logic();
   init_api3();
-  init_assigned_task_snapshot_store();
-  init_convex_error();
-  init_execution_kind();
+  init_native_delivery_session_registry();
+  init_task_delivery_processor();
+  init_task_delivery_logic();
+  init_fetch_machine_assigned_task_snapshots();
+  init_inbox();
+  init_task_inbox_delivery();
+  init_task();
 });
 
 // src/daemon/entry/workspace-git/git-subscription.ts
@@ -116529,16 +116916,16 @@ var init_workspace_list_subscription = __esm(() => {
 
 // src/daemon/entry/workspace-git-inbound-registry.ts
 function registerWorkspaceGitInboundHandler(h) {
-  handler7 = h;
+  handler6 = h;
 }
 function unregisterWorkspaceGitInboundHandler() {
-  handler7 = undefined;
+  handler6 = undefined;
 }
 async function dispatchWorkspaceGitInboundEvent(event) {
-  if (handler7)
-    await handler7(event);
+  if (handler6)
+    await handler6(event);
 }
-var handler7;
+var handler6;
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 var onDaemonShutdownEffect;
@@ -116579,7 +116966,7 @@ function createDaemonRuntime(deps) {
   let directHarnessWorkerHandle = null;
   let agenticQueryWorkerHandle = null;
   let enhancerWorkerHandle = null;
-  let taskMonitorHandle = null;
+  let taskInboxHandle = null;
   const activeSessions = new Map;
   const harnesses = new Map;
   let signalCount = 0;
@@ -116614,7 +117001,7 @@ function createDaemonRuntime(deps) {
     gitSubscriptionHandle?.stop();
     fileTreeSubscriptionHandle?.stop();
     workspaceListSubscriptionHandle?.stop();
-    taskMonitorHandle?.stop();
+    taskInboxHandle?.stop();
     logObserverSubscriptionHandle?.stop();
     directHarnessWorkerHandle?.stop();
     agenticQueryWorkerHandle?.stop();
@@ -116720,7 +117107,7 @@ function createDaemonRuntime(deps) {
           break;
       }
     });
-    taskMonitorHandle = yield* startTaskMonitorEffect(deps.wsClient);
+    taskInboxHandle = yield* startTaskInboxEffect(deps.wsClient);
     logObserverSubscriptionHandle = startLogObserverSubscription({ sessionId: session2.sessionId, machineId: session2.machineId }, deps.wsClient);
     const commandRunRuntime = yield* exports_Effect.runtime();
     if (featureFlags.directHarnessWorkers) {
@@ -116780,7 +117167,7 @@ var init_daemon_runtime = __esm(() => {
   init_command_run_subscription();
   init_log_observer_sync();
   init_init_daemon();
-  init_task_monitor_runtime();
+  init_task_inbox_runtime();
   init_git_heartbeat();
   init_git_subscription();
   init_api3();
@@ -116808,24 +117195,6 @@ var init_agentic_query_bridge = __esm(() => {
   init_process_agentic_query_prompt();
 });
 
-// src/daemon/domain/usecase/deliver-assigned-task.ts
-async function deliverAssignedTaskInbound(deps, event) {
-  await deps.dispatchInbound(event);
-}
-
-// src/daemon/entry/bridge/assigned-task-bridge.ts
-function createDeliverAssignedTaskDeps() {
-  return { dispatchInbound: dispatchAssignedTaskMonitorEvent };
-}
-function createAssignedTaskRouterDeps() {
-  return {
-    deliverInbound: async (event) => {
-      await deliverAssignedTaskInbound(createDeliverAssignedTaskDeps(), event);
-    }
-  };
-}
-var init_assigned_task_bridge = () => {};
-
 // src/daemon/domain/usecase/handle-command-event.ts
 async function handleCommandEvent(deps, event) {
   await deps.dispatchInbound(event);
@@ -116943,7 +117312,6 @@ var init_workspace_git_bridge = () => {};
 // src/daemon/entry/default-router-deps.ts
 function createDefaultEventRouterDeps() {
   return {
-    assignedTask: createAssignedTaskRouterDeps(),
     directHarness: createDirectHarnessRouterDeps(),
     command: createCommandRouterDeps(),
     workspaceGit: createWorkspaceGitRouterDeps(),
@@ -116954,7 +117322,6 @@ function createDefaultEventRouterDeps() {
 }
 var init_default_router_deps = __esm(() => {
   init_agentic_query_bridge();
-  init_assigned_task_bridge();
   init_command_bridge();
   init_direct_harness_bridge();
   init_enhancer_bridge();
@@ -117335,10 +117702,10 @@ var init_deps = __esm(() => {
 });
 
 // src/daemon/entry/persistence-path.ts
-import { homedir as homedir10 } from "node:os";
-import { join as join26 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join27 } from "node:path";
 function resolvePersistenceDbPath(machineId) {
-  return join26(homedir10(), ".chatroom", "daemon", machineId, "events.sqlite");
+  return join27(homedir11(), ".chatroom", "daemon", machineId, "events.sqlite");
 }
 var init_persistence_path = () => {};
 
@@ -117349,13 +117716,6 @@ async function handleAgenticQueryInbound(deps, event) {
   }
 }
 
-// src/daemon/domain/usecase/handle-assigned-task-inbound.ts
-async function handleAssignedTaskInbound(deps, event) {
-  if (deps.deliverInbound) {
-    await deps.deliverInbound(event);
-  }
-}
-
 // src/daemon/domain/usecase/handle-command-inbound.ts
 async function handleCommandInbound(deps, event) {
   if (deps.deliverInbound) {
@@ -117394,10 +117754,6 @@ async function handleWorkspaceGitInbound(deps, event) {
 // src/daemon/entry/event-router.ts
 async function routeInboundEvent(deps, event) {
   switch (event.type) {
-    case "assigned-task.signal":
-    case "assigned-task.presence":
-      await handleAssignedTaskInbound(deps.assignedTask, event);
-      break;
     case "direct-harness.session-opened":
     case "direct-harness.prompt":
     case "direct-harness.command":
@@ -117496,403 +117852,6 @@ var init_agentic_query_session = __esm(() => {
   init_api3();
 });
 
-// src/infrastructure/incremental-sync/layers.ts
-var IntervalClock, IntervalClockLive;
-var init_layers = __esm(() => {
-  init_esm();
-  IntervalClock = class IntervalClock extends exports_Context.Tag("IntervalClock")() {
-  };
-  IntervalClockLive = exports_Layer.succeed(IntervalClock, {
-    sleep: (ms) => exports_Effect.promise(() => new Promise((resolve8) => setTimeout(resolve8, ms)))
-  });
-});
-
-// src/infrastructure/incremental-sync/message-buffer.ts
-class MessageBuffer {
-  keyOf;
-  queue = [];
-  inBuffer = new Set;
-  inFlight = new Map;
-  recentlyAcked = new Map;
-  dedupe;
-  dedupeTtlMs;
-  maxSize;
-  constructor(config4, keyOf) {
-    this.keyOf = keyOf;
-    this.dedupe = config4.dedupe ?? true;
-    this.dedupeTtlMs = config4.dedupeTtlMs ?? 0;
-    this.maxSize = config4.maxSize;
-  }
-  enqueue(items) {
-    this.pruneRecentlyAcked();
-    let enqueued = 0;
-    for (const item of items) {
-      const key = this.keyOf(item);
-      if (this.dedupe && this.shouldSkip(key)) {
-        continue;
-      }
-      this.queue.push({ key, item });
-      this.inBuffer.add(key);
-      enqueued++;
-    }
-    if (enqueued > 0) {
-      this.queue.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-    }
-    this.enforceMaxSize();
-    return enqueued;
-  }
-  dequeue() {
-    this.pruneRecentlyAcked();
-    const next4 = this.queue.shift();
-    if (!next4)
-      return;
-    this.inBuffer.delete(next4.key);
-    this.inFlight.set(next4.key, next4.item);
-    return next4.item;
-  }
-  ack(key) {
-    this.inFlight.delete(key);
-    if (this.dedupe) {
-      this.recentlyAcked.set(key, Date.now());
-    }
-  }
-  nack(key, requeue = false) {
-    const item = this.inFlight.get(key);
-    this.inFlight.delete(key);
-    if (requeue && item !== undefined) {
-      this.enqueue([item]);
-    }
-  }
-  size() {
-    return this.queue.length;
-  }
-  highKeyOf(items) {
-    if (items.length === 0)
-      return null;
-    let high = null;
-    for (const item of items) {
-      const key = this.keyOf(item);
-      if (high === null || key > high) {
-        high = key;
-      }
-    }
-    return high;
-  }
-  shouldSkip(key) {
-    if (this.inBuffer.has(key) || this.inFlight.has(key)) {
-      return true;
-    }
-    if (this.dedupeTtlMs > 0) {
-      const ackedAt = this.recentlyAcked.get(key);
-      if (ackedAt !== undefined && Date.now() - ackedAt < this.dedupeTtlMs) {
-        return true;
-      }
-    } else if (this.recentlyAcked.has(key)) {
-      return true;
-    }
-    return false;
-  }
-  pruneRecentlyAcked() {
-    if (this.dedupeTtlMs <= 0)
-      return;
-    const now = Date.now();
-    for (const [key, ackedAt] of this.recentlyAcked) {
-      if (now - ackedAt >= this.dedupeTtlMs) {
-        this.recentlyAcked.delete(key);
-      }
-    }
-  }
-  enforceMaxSize() {
-    while (this.queue.length > this.maxSize) {
-      const dropped = this.queue.shift();
-      if (dropped) {
-        this.inBuffer.delete(dropped.key);
-        console.warn(`[incremental-sync] Buffer full — dropped oldest unacked item (key=${dropped.key})`);
-      }
-    }
-  }
-}
-// src/infrastructure/incremental-sync/resolve-high-key.ts
-function resolveHighKey(def, buffer, page) {
-  if (page.highKey !== null)
-    return page.highKey;
-  const fromItems = buffer.highKeyOf(page.items);
-  if (fromItems !== null)
-    return fromItems;
-  if (def.itemToKey && page.items.length > 0) {
-    let high = null;
-    for (const item of page.items) {
-      const key = def.itemToKey(item);
-      if (high === null || key > high)
-        high = key;
-    }
-    return high;
-  }
-  return null;
-}
-
-// src/infrastructure/incremental-sync/subscribe-loop.ts
-function parseFeedItems(def, items, onError3) {
-  if (!def.parseItem) {
-    return items;
-  }
-  const parsed = [];
-  for (const raw of items) {
-    try {
-      parsed.push(def.parseItem(raw));
-    } catch (err) {
-      onError3?.(err);
-    }
-  }
-  return parsed;
-}
-function startSubscribeLoop(opts) {
-  let afterKey = opts.initialAfterKey ?? null;
-  let stopped = false;
-  let unsubscribe;
-  let drainInFlight = false;
-  const subscribe = () => {
-    if (stopped)
-      return;
-    unsubscribe?.();
-    unsubscribe = opts.wsClient.onUpdate(opts.target.query, opts.target.buildArgs(opts.args, afterKey, opts.config.limit), (result) => {
-      if (stopped)
-        return;
-      const page = opts.target.parsePage(result);
-      drainPages(page);
-    }, (err) => {
-      opts.onError?.(err);
-    });
-  };
-  const fetchPage = async (cursor) => {
-    const result = await opts.wsClient.query(opts.target.query, opts.target.buildArgs(opts.args, cursor, opts.config.limit));
-    return opts.target.parsePage(result);
-  };
-  const drainPages = async (initialPage) => {
-    if (stopped || drainInFlight)
-      return;
-    drainInFlight = true;
-    try {
-      const cursorAtStart = afterKey;
-      let page = initialPage;
-      while (!stopped && page.items.length > 0) {
-        const items = parseFeedItems(opts.def, page.items, opts.onError);
-        if (items.length > 0) {
-          opts.buffer.enqueue(items);
-        }
-        const nextKey = resolveHighKey(opts.def, opts.buffer, page);
-        if (nextKey === null) {
-          break;
-        }
-        afterKey = nextKey;
-        if (!page.hasMore) {
-          break;
-        }
-        page = await fetchPage(afterKey);
-      }
-      if (!stopped && afterKey !== cursorAtStart) {
-        subscribe();
-      }
-    } catch (err) {
-      opts.onError?.(err);
-    } finally {
-      drainInFlight = false;
-    }
-  };
-  subscribe();
-  return {
-    stop: () => {
-      stopped = true;
-      unsubscribe?.();
-      unsubscribe = undefined;
-    },
-    getAfterKey: () => afterKey
-  };
-}
-var init_subscribe_loop = () => {};
-
-// src/infrastructure/incremental-sync/feed-runtime.ts
-function runWorkerLoop(feedName, buffer, keyOf, onItem) {
-  return exports_Effect.gen(function* () {
-    while (true) {
-      const item = buffer.dequeue();
-      if (item === undefined) {
-        yield* exports_Effect.sleep("10 millis");
-        continue;
-      }
-      const key = keyOf(item);
-      const ctx = {
-        item,
-        feedName,
-        ack: () => buffer.ack(key),
-        nack: (opts) => buffer.nack(key, opts?.requeue ?? false)
-      };
-      yield* onItem(ctx).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    }
-  });
-}
-var runIncrementalSubscribeLive = (opts) => exports_Effect.gen(function* () {
-  const buffer = new MessageBuffer(opts.buffer, opts.def.itemKey);
-  const subscribeHandle = startSubscribeLoop({
-    wsClient: opts.wsClient,
-    target: opts.target,
-    args: opts.args,
-    buffer,
-    def: opts.def,
-    config: opts.subscribe,
-    initialAfterKey: opts.initialAfterKey ?? null,
-    onError: opts.onError
-  });
-  const workerFiber = yield* exports_Effect.forkDaemon(runWorkerLoop(opts.def.name, buffer, opts.def.itemKey, opts.onItem));
-  return {
-    buffer,
-    stop: () => exports_Effect.gen(function* () {
-      subscribeHandle.stop();
-      yield* exports_Fiber.interrupt(workerFiber);
-    })
-  };
-});
-var init_feed_runtime = __esm(() => {
-  init_esm();
-  init_layers();
-  init_subscribe_loop();
-});
-
-// src/infrastructure/incremental-sync/feeds/assigned-task-presence.ts
-var assignedTaskPresenceFeedDef, assignedTaskPresenceSubscribeTarget, ASSIGNED_TASK_PRESENCE_FEED_LIMIT = 50, ASSIGNED_TASK_PRESENCE_FEED_BUFFER;
-var init_assigned_task_presence = __esm(() => {
-  init_assigned_task_monitor_contract();
-  init_api3();
-  assignedTaskPresenceFeedDef = {
-    name: "assigned-task-presence",
-    itemKey: (item) => item.presenceKey,
-    parseItem: parseAssignedTaskPresenceSignal
-  };
-  assignedTaskPresenceSubscribeTarget = {
-    query: api.machines.subscribeAssignedTaskPresenceSince,
-    buildArgs: (args2, afterKey, limit) => ({
-      sessionId: args2.sessionId,
-      machineId: args2.machineId,
-      afterPresenceKey: afterKey ?? undefined,
-      limit
-    }),
-    parsePage: (result) => {
-      const page = result;
-      return {
-        items: page.items,
-        highKey: page.highPresenceKey,
-        hasMore: page.hasMore
-      };
-    }
-  };
-  ASSIGNED_TASK_PRESENCE_FEED_BUFFER = {
-    maxSize: 200,
-    dedupe: true
-  };
-});
-
-// src/daemon/infrastructure/convex/subscribers/assigned-task-presence.ts
-function startAssignedTaskPresenceSubscriber(deps, onEvent) {
-  let stopped = false;
-  const startPromise = exports_Effect.runPromise(runIncrementalSubscribeLive({
-    wsClient: deps.wsClient,
-    def: assignedTaskPresenceFeedDef,
-    target: assignedTaskPresenceSubscribeTarget,
-    args: { sessionId: deps.sessionId, machineId: deps.machineId },
-    buffer: ASSIGNED_TASK_PRESENCE_FEED_BUFFER,
-    subscribe: { limit: ASSIGNED_TASK_PRESENCE_FEED_LIMIT },
-    onItem: ({ item, ack }) => exports_Effect.sync(() => {
-      if (stopped)
-        return;
-      ack();
-      onEvent({ type: "assigned-task.presence", taskId: item.taskId, role: item.role });
-    }),
-    onError: (err) => {
-      console.warn(`[daemon] assigned-task-presence subscriber error: ${String(err)}`);
-    }
-  }));
-  let feedHandle;
-  startPromise.then((handle) => {
-    feedHandle = handle;
-  });
-  return {
-    async stop() {
-      stopped = true;
-      const handle = feedHandle ?? await startPromise;
-      await exports_Effect.runPromise(handle.stop());
-    }
-  };
-}
-var init_assigned_task_presence2 = __esm(() => {
-  init_esm();
-  init_feed_runtime();
-  init_assigned_task_presence();
-});
-
-// src/infrastructure/incremental-sync/feeds/assigned-task-signals.ts
-var assignedTaskSignalsFeedDef, assignedTaskSignalsSubscribeTarget, ASSIGNED_TASK_SIGNAL_FEED_LIMIT = 50, ASSIGNED_TASK_SIGNAL_FEED_BUFFER;
-var init_assigned_task_signals = __esm(() => {
-  init_assigned_task_monitor_contract();
-  init_api3();
-  assignedTaskSignalsFeedDef = {
-    name: "assigned-task-signals",
-    itemKey: (item) => item.revisionKey,
-    parseItem: parseAssignedTaskSignal
-  };
-  assignedTaskSignalsSubscribeTarget = {
-    query: api.machines.subscribeAssignedTaskSignalsSince,
-    buildArgs: (args2, afterKey, limit) => ({
-      sessionId: args2.sessionId,
-      machineId: args2.machineId,
-      afterKey: afterKey ?? undefined,
-      limit
-    }),
-    parsePage: (result) => result
-  };
-  ASSIGNED_TASK_SIGNAL_FEED_BUFFER = {
-    maxSize: 200,
-    dedupe: true
-  };
-});
-
-// src/daemon/infrastructure/convex/subscribers/assigned-task-signals.ts
-function startAssignedTaskSignalsSubscriber(deps, onEvent) {
-  let stopped = false;
-  const startPromise = exports_Effect.runPromise(runIncrementalSubscribeLive({
-    wsClient: deps.wsClient,
-    def: assignedTaskSignalsFeedDef,
-    target: assignedTaskSignalsSubscribeTarget,
-    args: { sessionId: deps.sessionId, machineId: deps.machineId },
-    buffer: ASSIGNED_TASK_SIGNAL_FEED_BUFFER,
-    subscribe: { limit: ASSIGNED_TASK_SIGNAL_FEED_LIMIT },
-    onItem: ({ item, ack }) => exports_Effect.sync(() => {
-      if (stopped)
-        return;
-      ack();
-      onEvent({ type: "assigned-task.signal", taskId: item.taskId, role: item.role });
-    }),
-    onError: (err) => {
-      console.warn(`[daemon] assigned-task-signals subscriber error: ${String(err)}`);
-    }
-  }));
-  let feedHandle;
-  startPromise.then((handle) => {
-    feedHandle = handle;
-  });
-  return {
-    async stop() {
-      stopped = true;
-      const handle = feedHandle ?? await startPromise;
-      await exports_Effect.runPromise(handle.stop());
-    }
-  };
-}
-var init_assigned_task_signals2 = __esm(() => {
-  init_esm();
-  init_feed_runtime();
-  init_assigned_task_signals();
-});
-
 // src/daemon/infrastructure/convex/subscribers/command-events.ts
 function startCommandEventsSubscriber(deps, onEvent) {
   const seen = new Set;
@@ -118280,10 +118239,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)}`);
@@ -118304,8 +118263,6 @@ function startAllSubscribers(deps) {
   const onEvent = (event) => {
     routeInboundEvent(deps.router, event);
   };
-  const signals = startAssignedTaskSignalsSubscriber(deps, onEvent);
-  const presence = startAssignedTaskPresenceSubscriber(deps, onEvent);
   const session2 = startDirectHarnessSessionSubscriber(deps, onEvent);
   const prompt = startDirectHarnessPromptSubscriber(deps, onEvent);
   const directHarnessCommand = startDirectHarnessCommandSubscriber(deps, onEvent);
@@ -118323,8 +118280,6 @@ function startAllSubscribers(deps) {
   return {
     async stopAll() {
       await Promise.all([
-        signals.stop(),
-        presence.stop(),
         session2.stop(),
         prompt.stop(),
         directHarnessCommand.stop(),
@@ -118347,8 +118302,6 @@ var init_subscriber_registry = __esm(() => {
   init_event_router();
   init_agentic_query_prompt();
   init_agentic_query_session();
-  init_assigned_task_presence2();
-  init_assigned_task_signals2();
   init_command_events();
   init_command_run();
   init_direct_harness_command();
@@ -118378,19 +118331,19 @@ function resolveEnvSlug(convexUrl) {
 }
 
 // src/infrastructure/log-server/resolve-logs-db-path.ts
-import { homedir as homedir11 } from "node:os";
-import { join as join27 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join28 } from "node:path";
 function resolveLogsDbPath(convexUrl) {
-  return join27(homedir11(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
+  return join28(homedir12(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
 }
 var init_resolve_logs_db_path = __esm(() => {
   init_client2();
 });
 
 // src/infrastructure/log-server/log-schema.ts
-var SCHEMA_VERSION = 2, MIGRATIONS;
+var SCHEMA_VERSION2 = 2, MIGRATIONS2;
 var init_log_schema = __esm(() => {
-  MIGRATIONS = [
+  MIGRATIONS2 = [
     `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
     `CREATE TABLE IF NOT EXISTS log_entries (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -118414,18 +118367,18 @@ var init_log_schema = __esm(() => {
 });
 
 // src/infrastructure/log-server/open-log-database.ts
-import { mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
-import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { mkdirSync as mkdirSync9 } from "node:fs";
+import { dirname as dirname16 } from "node:path";
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 function openLogDatabase(dbPath) {
-  mkdirSync8(dirname15(dbPath), { recursive: true });
-  const db = new DatabaseSync3(dbPath);
+  mkdirSync9(dirname16(dbPath), { recursive: true });
+  const db = new DatabaseSync4(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA synchronous = NORMAL");
-  for (const migration of MIGRATIONS)
+  for (const migration of MIGRATIONS2)
     db.exec(migration);
-  db.prepare(`INSERT INTO schema_meta(key,value) VALUES('version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(String(SCHEMA_VERSION));
+  db.prepare(`INSERT INTO schema_meta(key,value) VALUES('version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(String(SCHEMA_VERSION2));
   return db;
 }
 var init_open_log_database = __esm(() => {
@@ -118474,8 +118427,8 @@ function queryEventStream(db, input) {
     ...input.toTimestamp !== undefined ? [input.toTimestamp] : [],
     clamp4(input.limit)
   ];
-  const rows2 = db.prepare(`SELECT * FROM event_stream_entries WHERE 1=1 ${filters} ORDER BY id DESC LIMIT ?`).all(...values3);
-  return rows2.reverse().map((row) => ({
+  const rows = db.prepare(`SELECT * FROM event_stream_entries WHERE 1=1 ${filters} ORDER BY id DESC LIMIT ?`).all(...values3);
+  return rows.reverse().map((row) => ({
     id: Number(row.id),
     timestamp: Number(row.timestamp),
     type: row.type,
@@ -118501,8 +118454,8 @@ function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, ha
     ...toTimestamp !== undefined ? [toTimestamp] : [],
     clamp4(limit)
   ];
-  const rows2 = db.prepare(`SELECT * FROM log_entries WHERE id > ? ${filters} ORDER BY id ASC LIMIT ?`).all(...values3);
-  return rows2.map(map19);
+  const rows = db.prepare(`SELECT * FROM log_entries WHERE id > ? ${filters} ORDER BY id ASC LIMIT ?`).all(...values3);
+  return rows.map(map19);
 }
 function queryHistory(db, beforeId, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
@@ -118524,8 +118477,8 @@ function queryHistory(db, beforeId, limit = 100, source, chatroomId, role, harne
     ...toTimestamp !== undefined ? [toTimestamp] : [],
     clamp4(limit)
   ];
-  const rows2 = db.prepare(`SELECT * FROM log_entries WHERE 1=1 ${filters} ORDER BY id DESC LIMIT ?`).all(...values3);
-  return rows2.map(map19).reverse();
+  const rows = db.prepare(`SELECT * FROM log_entries WHERE 1=1 ${filters} ORDER BY id DESC LIMIT ?`).all(...values3);
+  return rows.map(map19).reverse();
 }
 function listLogDimensions(db, chatroomId, limit = 100) {
   const clamped = clamp4(limit);
@@ -118614,9 +118567,9 @@ function appendOutboundEvent(db, event) {
 }
 
 // src/daemon/infrastructure/persistence/schema.ts
-var SCHEMA_VERSION2 = 1, MIGRATIONS2;
-var init_schema = __esm(() => {
-  MIGRATIONS2 = [
+var SCHEMA_VERSION3 = 1, MIGRATIONS3;
+var init_schema2 = __esm(() => {
+  MIGRATIONS3 = [
     `CREATE TABLE IF NOT EXISTS schema_meta (
     key TEXT PRIMARY KEY,
     value TEXT NOT NULL
@@ -118645,21 +118598,21 @@ var init_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/persistence/open-database.ts
-import { mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
-import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
-function openDatabase(dbPath) {
-  mkdirSync9(dirname16(dbPath), { recursive: true });
-  const db = new DatabaseSync4(dbPath);
-  for (const sql of MIGRATIONS2) {
+import { mkdirSync as mkdirSync10 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
+import { DatabaseSync as DatabaseSync5 } from "node:sqlite";
+function openDatabase2(dbPath) {
+  mkdirSync10(dirname17(dbPath), { recursive: true });
+  const db = new DatabaseSync5(dbPath);
+  for (const sql of MIGRATIONS3) {
     db.exec(sql);
   }
   db.prepare(`INSERT INTO schema_meta(key, value) VALUES('version', ?)
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(SCHEMA_VERSION2));
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(SCHEMA_VERSION3));
   return db;
 }
-var init_open_database = __esm(() => {
-  init_schema();
+var init_open_database2 = __esm(() => {
+  init_schema2();
 });
 
 // src/daemon/infrastructure/persistence/outbox.ts
@@ -118677,10 +118630,10 @@ function listPendingOutbox(db, limit = 100) {
 // src/daemon/infrastructure/persistence/read-model.ts
 function listHarnessStreamLines(db, opts = {}) {
   const limit = opts.limit ?? 500;
-  const rows2 = db.prepare(`SELECT payload_json FROM outbound_events
+  const rows = db.prepare(`SELECT payload_json FROM outbound_events
        WHERE event_type = 'harness.stream'
        ORDER BY id DESC LIMIT ?`).all(limit);
-  const parsed = rows2.map((row) => JSON.parse(row.payload_json)).filter((event) => event.type === "harness.stream");
+  const parsed = rows.map((row) => JSON.parse(row.payload_json)).filter((event) => event.type === "harness.stream");
   if (!opts.harness)
     return parsed.reverse();
   return parsed.filter((e) => e.harness === opts.harness).reverse();
@@ -118688,7 +118641,7 @@ function listHarnessStreamLines(db, opts = {}) {
 
 // src/daemon/infrastructure/persistence/persistence-store.ts
 function createPersistenceStore(dbPath) {
-  const db = openDatabase(dbPath);
+  const db = openDatabase2(dbPath);
   return {
     append(event) {
       const eventId = appendOutboundEvent(db, event);
@@ -118702,7 +118655,7 @@ function createPersistenceStore(dbPath) {
   };
 }
 var init_persistence_store = __esm(() => {
-  init_open_database();
+  init_open_database2();
 });
 
 // src/daemon/infrastructure/persistence/index.ts
@@ -121435,9 +121388,9 @@ var require_event_target2 = __commonJS((exports, module) => {
   }
   Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
   var EventTarget = {
-    addEventListener(type, handler8, options = {}) {
+    addEventListener(type, handler7, options = {}) {
       for (const listener of this.listeners(type)) {
-        if (!options[kForOnEventAttribute] && listener[kListener] === handler8 && !listener[kForOnEventAttribute]) {
+        if (!options[kForOnEventAttribute] && listener[kListener] === handler7 && !listener[kForOnEventAttribute]) {
           return;
         }
       }
@@ -121448,7 +121401,7 @@ var require_event_target2 = __commonJS((exports, module) => {
             data: isBinary ? data : data.toString()
           });
           event[kTarget] = this;
-          callListener(handler8, this, event);
+          callListener(handler7, this, event);
         };
       } else if (type === "close") {
         wrapper = function onClose(code2, message) {
@@ -121458,7 +121411,7 @@ var require_event_target2 = __commonJS((exports, module) => {
             wasClean: this._closeFrameReceived && this._closeFrameSent
           });
           event[kTarget] = this;
-          callListener(handler8, this, event);
+          callListener(handler7, this, event);
         };
       } else if (type === "error") {
         wrapper = function onError3(error51) {
@@ -121467,28 +121420,28 @@ var require_event_target2 = __commonJS((exports, module) => {
             message: error51.message
           });
           event[kTarget] = this;
-          callListener(handler8, this, event);
+          callListener(handler7, this, event);
         };
       } else if (type === "open") {
         wrapper = function onOpen() {
           const event = new Event2("open");
           event[kTarget] = this;
-          callListener(handler8, this, event);
+          callListener(handler7, this, event);
         };
       } else {
         return;
       }
       wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
-      wrapper[kListener] = handler8;
+      wrapper[kListener] = handler7;
       if (options.once) {
         this.once(type, wrapper);
       } else {
         this.on(type, wrapper);
       }
     },
-    removeEventListener(type, handler8) {
+    removeEventListener(type, handler7) {
       for (const listener of this.listeners(type)) {
-        if (listener[kListener] === handler8 && !listener[kForOnEventAttribute]) {
+        if (listener[kListener] === handler7 && !listener[kForOnEventAttribute]) {
           this.removeListener(type, listener);
           break;
         }
@@ -122017,16 +121970,16 @@ var require_websocket2 = __commonJS((exports, module) => {
         }
         return null;
       },
-      set(handler8) {
+      set(handler7) {
         for (const listener of this.listeners(method)) {
           if (listener[kForOnEventAttribute]) {
             this.removeListener(method, listener);
             break;
           }
         }
-        if (typeof handler8 !== "function")
+        if (typeof handler7 !== "function")
           return;
-        this.addEventListener(method, handler8, {
+        this.addEventListener(method, handler7, {
           [kForOnEventAttribute]: true
         });
       }
@@ -132360,19 +132313,19 @@ function routeRequest(req, res, deps) {
 
 // src/daemon/local-web/server/serve-static.ts
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname17, join as join28 } from "node:path";
+import { dirname as dirname18, join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function clientDistCandidates(here) {
   return [
-    join28(here, "client/build"),
-    join28(here, "../client/build"),
-    join28(here, "../src/daemon/local-web/client/build")
+    join29(here, "client/build"),
+    join29(here, "../client/build"),
+    join29(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir(here = dirname17(fileURLToPath7(import.meta.url))) {
+function resolveClientDistDir(here = dirname18(fileURLToPath7(import.meta.url))) {
   const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
-    if (existsSync10(join28(dir, "index.html")))
+    if (existsSync10(join29(dir, "index.html")))
       return dir;
   }
   return candidates[0];
@@ -132385,7 +132338,7 @@ function tryServeStatic(req, res, distDir) {
     return false;
   }
   const safePath = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join28(distDir, safePath);
+  const filePath = join29(distDir, safePath);
   if (!filePath.startsWith(distDir)) {
     res.writeHead(403);
     res.end();
@@ -132402,7 +132355,7 @@ function tryServeStatic(req, res, distDir) {
     }
     return true;
   }
-  const indexPath = join28(distDir, "index.html");
+  const indexPath = join29(distDir, "index.html");
   if (existsSync10(indexPath)) {
     res.writeHead(200, { "Content-Type": "text/html" });
     if (req.method === "HEAD") {
@@ -132984,7 +132937,7 @@ async function harnessStatus() {
   };
   const program2 = exports_Effect.forEach(services, detectOne, { concurrency: "unbounded" });
   const results = await exports_Effect.runPromise(program2);
-  const rows2 = results.map(({ id: id3, displayName, result }) => {
+  const rows = results.map(({ id: id3, displayName, result }) => {
     if (isInstalled(result)) {
       return { id: id3, displayName, status: "installed" };
     }
@@ -132996,13 +132949,13 @@ async function harnessStatus() {
     }
     return { id: id3, displayName, status: "not-installed" };
   });
-  const idWidth = Math.max(4, ...rows2.map((r) => r.id.length));
-  const nameWidth = Math.max(11, ...rows2.map((r) => r.displayName.length));
+  const idWidth = Math.max(4, ...rows.map((r) => r.id.length));
+  const nameWidth = Math.max(11, ...rows.map((r) => r.displayName.length));
   const header = `${"ID".padEnd(idWidth)}  ${"DISPLAY NAME".padEnd(nameWidth)}  STATUS`;
   const divider = `${"-".repeat(idWidth)}  ${"-".repeat(nameWidth)}  ------`;
   console.log(header);
   console.log(divider);
-  for (const row of rows2) {
+  for (const row of rows) {
     const statusIcon = row.status === "installed" ? "✅ installed" : row.status === "error" ? "⚠️  error" : "❌ not installed";
     const line = `${row.id.padEnd(idWidth)}  ${row.displayName.padEnd(nameWidth)}  ${statusIcon}`;
     console.log(line);
@@ -133011,8 +132964,8 @@ async function harnessStatus() {
     }
   }
   console.log("");
-  const installedCount = rows2.filter((r) => r.status === "installed").length;
-  const totalCount = rows2.length;
+  const installedCount = rows.filter((r) => r.status === "installed").length;
+  const totalCount = rows.length;
   console.log(`${installedCount}/${totalCount} harnesses available on this machine.`);
 }
 var init_harness_status = __esm(() => {
@@ -134133,4 +134086,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D41963016C23E20F64756E2164756E21
+//# debugId=D3E73C85EB221DCE64756E2164756E21