chatroom-cli 1.110.1 → 1.112.0

package/dist/index.js

@@ -28278,6 +28278,64 @@ var init_agent_process_service = __esm(() => {
   init_service();
 });
 
+// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/infra/in-memory-active-task-state-store.ts
+function keyOf(key) {
+  return `${key.chatroomId}:${key.role.toLowerCase()}`;
+}
+
+class InMemoryActiveTaskStateStore {
+  states = new Map;
+  get(key) {
+    const state = this.states.get(keyOf(key));
+    return state ? { ...state } : undefined;
+  }
+  start(input) {
+    const state = {
+      chatroomId: input.chatroomId,
+      role: input.role,
+      taskId: input.taskId
+    };
+    this.states.set(keyOf(input), state);
+    return { ...state };
+  }
+  clear(key) {
+    return this.states.delete(keyOf(key));
+  }
+  clearAll() {
+    const count3 = this.states.size;
+    this.states.clear();
+    return count3;
+  }
+}
+
+// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/usecase/agent-task-state-service.ts
+class DefaultAgentTaskStateService {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get(key) {
+    return this.deps.taskState.get(key);
+  }
+  start(input) {
+    return this.deps.taskState.start(input);
+  }
+  clear(key) {
+    return this.deps.taskState.clear(key);
+  }
+  clearAll() {
+    return this.deps.taskState.clearAll();
+  }
+}
+
+// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/index.ts
+function createAgentTaskStateService() {
+  return new DefaultAgentTaskStateService({
+    taskState: new InMemoryActiveTaskStateStore
+  });
+}
+var init_agent_task_state = () => {};
+
 // src/daemon/services/agent-process-service/domain/usecase/native-turn-phase.ts
 function defaultNativeTurnPhase() {
   return "idle";
@@ -30996,6 +31054,7 @@ var init_harness_activity_emitter = __esm(() => {
 // src/daemon/services/agent-process-service/index.ts
 var init_agent_process_service2 = __esm(() => {
   init_agent_process_service();
+  init_agent_task_state();
   init_agent_process_command_bus();
   init_service();
   init_agent_process_manager();
@@ -31005,64 +31064,6 @@ var init_agent_process_service2 = __esm(() => {
   init_orphan_process_tracker();
 });
 
-// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/infra/in-memory-active-task-state-store.ts
-function keyOf(key) {
-  return `${key.chatroomId}:${key.role.toLowerCase()}`;
-}
-
-class InMemoryActiveTaskStateStore {
-  states = new Map;
-  get(key) {
-    const state = this.states.get(keyOf(key));
-    return state ? { ...state } : undefined;
-  }
-  start(input) {
-    const state = {
-      chatroomId: input.chatroomId,
-      role: input.role,
-      taskId: input.taskId
-    };
-    this.states.set(keyOf(input), state);
-    return { ...state };
-  }
-  clear(key) {
-    return this.states.delete(keyOf(key));
-  }
-  clearAll() {
-    const count3 = this.states.size;
-    this.states.clear();
-    return count3;
-  }
-}
-
-// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/usecase/agent-task-state-service.ts
-class DefaultAgentTaskStateService {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  get(key) {
-    return this.deps.taskState.get(key);
-  }
-  start(input) {
-    return this.deps.taskState.start(input);
-  }
-  clear(key) {
-    return this.deps.taskState.clear(key);
-  }
-  clearAll() {
-    return this.deps.taskState.clearAll();
-  }
-}
-
-// src/daemon/services/agent-process-service/infrastructure/components/agent-task-state/index.ts
-function createAgentTaskStateService() {
-  return new DefaultAgentTaskStateService({
-    taskState: new InMemoryActiveTaskStateStore
-  });
-}
-var init_agent_task_state = () => {};
-
 // src/daemon/services/agent-process-contracts.ts
 var init_agent_process_contracts = __esm(() => {
   init_agent_process_service2();
@@ -31786,6 +31787,595 @@ var init_native_task_injector = __esm(() => {
   init_native_task_injector_logic();
 });
 
+// src/daemon/services/task-service/service/native-delivery/native-delivery-log.ts
+function logNativeDeliveryDecision(source, role, chatroomId, decision, taskId, details) {
+  const taskSuffix = taskId ? ` task=${taskId}` : "";
+  const detailSuffix = details ? Object.entries(details).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}=${value}`).join(" ") : "";
+  console.log(`[NativeDelivery:decision] source=${source} role=${role} chatroom=${chatroomId}${taskSuffix} decision=${decision}${detailSuffix ? ` ${detailSuffix}` : ""}`);
+}
+function logNativeDeliveryTrigger(source, role, chatroomId, taskId) {
+  const taskSuffix = taskId ? ` task ${taskId}` : "";
+  console.log(`[NativeDelivery:trigger] source=${source} ${role}@${chatroomId}${taskSuffix}`);
+}
+function logNativeDeliverySkip(role, chatroomId, taskId, reason) {
+  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — ${reason}`);
+}
+function logNativeDeliveryMutexSkip(role, chatroomId, taskId) {
+  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — delivery_mutex_busy (another inject in flight)`);
+}
+function logNativeDeliveryInjecting(role, chatroomId, taskId) {
+  console.log(`[NativeDelivery:inject] ${role}@${chatroomId} task ${taskId} — starting injection`);
+}
+
+// src/daemon/services/task-service/service/native-delivery/delivery-decision.ts
+function taskSort(a, b) {
+  const pendingOrder = Number(b.status === "pending") - Number(a.status === "pending");
+  return pendingOrder || a.createdAt - b.createdAt;
+}
+function stableBlockReason(reason) {
+  const reasons = [
+    "not_native_harness",
+    "task_status_not_deliverable",
+    "acknowledged_wrong_role",
+    "chatroom_stop_scope_active",
+    "operational_stop_intent_active",
+    "operational_circuit_open",
+    "operational_state_not_running",
+    "slot_missing",
+    "slot_not_running",
+    "slot_pid_missing",
+    "spawned_pid_missing",
+    "pid_mismatch",
+    "harness_session_missing",
+    "turn_not_idle",
+    "working_dir_missing"
+  ];
+  return reasons.find((candidate) => reason.startsWith(candidate)) ?? "working_dir_missing";
+}
+function decideNextDelivery(tasks, context5) {
+  const assignedTasks = [...tasks].filter((candidate) => candidate.agentConfig.role.toLowerCase() === context5.role.toLowerCase()).sort(taskSort);
+  const task = assignedTasks.find((candidate) => isDeliverableTaskStatus(candidate.status));
+  if (!task) {
+    if (assignedTasks.length > 0) {
+      return {
+        kind: "blocked",
+        taskId: assignedTasks[0].taskId,
+        reason: "task_status_not_deliverable"
+      };
+    }
+    return { kind: "idle", reason: tasks.length > 0 ? "not_assigned" : "no_deliverable_task" };
+  }
+  if (context5.activeTaskId === task.taskId) {
+    return { kind: "deduplicated", taskId: task.taskId, reason: "task_state_active" };
+  }
+  if (context5.deliveryInFlight) {
+    return { kind: "deduplicated", taskId: task.taskId, reason: "delivery_in_flight" };
+  }
+  if (!context5.isNativeHarness(task.agentConfig.agentHarness)) {
+    return { kind: "blocked", taskId: task.taskId, reason: "not_native_harness" };
+  }
+  if (context5.agentLifecycleInFlight) {
+    return { kind: "wait", taskId: task.taskId, reason: "agent_start_in_flight" };
+  }
+  const blockReason = context5.explainNativeDeliveryBlock(task, {
+    slot: context5.slot,
+    operational: context5.operational
+  });
+  if (blockReason === null) {
+    return {
+      kind: "inject",
+      taskId: task.taskId,
+      harnessSessionId: context5.slot?.harnessSessionId
+    };
+  }
+  if (isSlotSpawning(context5.slot?.state ?? "idle")) {
+    return { kind: "wait", taskId: task.taskId, reason: "slot_spawning" };
+  }
+  if (isSlotStopping(context5.slot?.state ?? "idle")) {
+    return { kind: "wait", taskId: task.taskId, reason: "slot_stopping" };
+  }
+  const coldSession = context5.snapshotRequestsNativeColdSession(task);
+  const startAllowed = blockReason.startsWith("slot_missing") || blockReason.startsWith("slot_not_running") || blockReason.startsWith("spawned_pid_missing");
+  if (startAllowed && !coldSession && task.status === "pending" && isSlotIdle(context5.slot?.state ?? "idle") && task.agentConfig.workingDir) {
+    return { kind: "start-agent", taskId: task.taskId };
+  }
+  if (blockReason.startsWith("harness_session_missing")) {
+    return { kind: "wait", taskId: task.taskId, reason: "session_not_ready" };
+  }
+  return { kind: "blocked", taskId: task.taskId, reason: stableBlockReason(blockReason) };
+}
+var init_delivery_decision = __esm(() => {
+  init_assigned_task();
+  init_check_agent_slot();
+});
+
+// src/infrastructure/mappers/map-assigned-task.ts
+function mapAssignedTaskSnapshot(row) {
+  return {
+    taskId: row.taskId,
+    chatroomId: row.chatroomId,
+    status: row.status,
+    assignedTo: row.assignedTo,
+    updatedAt: row.updatedAt,
+    createdAt: row.createdAt,
+    agentConfig: {
+      role: row.agentConfig.role,
+      machineId: row.agentConfig.machineId,
+      agentHarness: row.agentConfig.agentHarness,
+      model: row.agentConfig.model,
+      workingDir: row.agentConfig.workingDir,
+      spawnedAgentPid: row.agentConfig.spawnedAgentPid,
+      desiredState: row.agentConfig.desiredState,
+      circuitState: row.agentConfig.circuitState,
+      configLifecycleRevision: row.agentConfig.configLifecycleRevision
+    },
+    participant: row.participant,
+    requestsNativeColdSession: row.requestsNativeColdSession
+  };
+}
+function mapAssignedTaskView(row) {
+  return {
+    ...mapAssignedTaskSnapshot(row),
+    taskContent: row.taskContent,
+    taskEnvelope: row.taskEnvelope,
+    startInNewSession: row.startInNewSession
+  };
+}
+function mapAssignedTaskSnapshotList(rows) {
+  return rows.map(mapAssignedTaskSnapshot);
+}
+
+// src/daemon/entry/restart-orchestrator-in-flight.ts
+function roleKey(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
+  inFlight.set(roleKey(chatroomId, role), correlationId);
+}
+function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
+  const key = roleKey(chatroomId, role);
+  if (correlationId !== undefined && inFlight.get(key) !== correlationId)
+    return;
+  inFlight.delete(key);
+}
+function isRestartOrchestratorInFlight(chatroomId, role) {
+  return inFlight.has(roleKey(chatroomId, role));
+}
+var inFlight;
+var init_restart_orchestrator_in_flight = __esm(() => {
+  inFlight = new Map;
+});
+
+// src/daemon/entry/role-delivery-state.ts
+function roleKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+
+class RoleDeliveryState {
+  generation = new Map;
+  inFlight = new Set;
+  nativeNudgeFailures = new Map;
+  getGeneration(chatroomId, role) {
+    return this.generation.get(roleKey2(chatroomId, role)) ?? 0;
+  }
+  resetDeliveryState(chatroomId, role) {
+    const key = roleKey2(chatroomId, role);
+    const next4 = (this.generation.get(key) ?? 0) + 1;
+    this.generation.set(key, next4);
+    this.inFlight.delete(key);
+    this.nativeNudgeFailures.delete(key);
+    return next4;
+  }
+  tryAcquireDelivery(chatroomId, role) {
+    const key = roleKey2(chatroomId, role);
+    if (this.inFlight.has(key))
+      return false;
+    this.inFlight.add(key);
+    return true;
+  }
+  releaseDelivery(chatroomId, role) {
+    this.inFlight.delete(roleKey2(chatroomId, role));
+  }
+  recordNativeNudgeFailure(chatroomId, role) {
+    const key = roleKey2(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));
+  }
+  getNativeNudgeFailures(chatroomId, role) {
+    return this.nativeNudgeFailures.get(roleKey2(chatroomId, role)) ?? 0;
+  }
+}
+function getRoleDeliveryState() {
+  shared ??= new RoleDeliveryState;
+  return shared;
+}
+var shared;
+
+// src/daemon/services/task-service/service/native-delivery/native-task-delivery-coordinator.ts
+class NativeTaskDeliveryCoordinator {
+  resetRoleDeliveryState(chatroomId, role) {
+    getRoleDeliveryState().resetDeliveryState(chatroomId, role);
+  }
+  async reconcileRoleTasks(params) {
+    const tasks = params.tasks;
+    if (tasks.length === 0)
+      return;
+    const {
+      runtime: runtime4,
+      effectContext: effectContext2,
+      agentMgr,
+      sessionDeps,
+      operationalModel,
+      isTaskActive,
+      machineId,
+      onTaskDelivered,
+      executors
+    } = params;
+    const deliveryState = getRoleDeliveryState();
+    const taskService = params.taskService;
+    const groups = new Map;
+    for (const task of tasks) {
+      const key = `${task.chatroomId}:${task.agentConfig.role.toLowerCase()}`;
+      const group = groups.get(key) ?? [];
+      group.push(task);
+      groups.set(key, group);
+    }
+    for (const roleTasks of groups.values()) {
+      const sortedTasks = [...roleTasks].sort((a, b) => {
+        if (a.status === "pending" && b.status !== "pending")
+          return -1;
+        if (b.status === "pending" && a.status !== "pending")
+          return 1;
+        return a.createdAt - b.createdAt;
+      });
+      const firstTask = sortedTasks[0];
+      if (!firstTask)
+        continue;
+      const { role } = firstTask.agentConfig;
+      const slot = agentMgr.getSlot(firstTask.chatroomId, role);
+      const operational = operationalModel.get(firstTask.chatroomId, role);
+      const activeTaskId = roleTasks.find((candidate) => isTaskActive({ chatroomId: candidate.chatroomId, role, taskId: candidate.taskId }))?.taskId;
+      const decision = decideNextDelivery(roleTasks, {
+        role,
+        slot,
+        operational,
+        activeTaskId,
+        deliveryInFlight: false,
+        agentLifecycleInFlight: isRestartOrchestratorInFlight(firstTask.chatroomId, role),
+        isNativeHarness: taskService.isNativeHarness,
+        snapshotRequestsNativeColdSession: taskService.snapshotRequestsNativeColdSession,
+        explainNativeDeliveryBlock: taskService.explainNativeDeliveryBlock
+      });
+      const attemptId = `${Date.now()}-${firstTask.taskId}`;
+      const decisionReason = "reason" in decision ? decision.reason : undefined;
+      logNativeDeliveryDecision(params.pass ?? "inbox-signal", role, firstTask.chatroomId, decision.kind === "blocked" || decision.kind === "wait" ? `${decision.kind}:${decision.reason}` : decision.kind, "taskId" in decision ? decision.taskId : undefined, {
+        ...decisionReason ? { reason: decisionReason } : {},
+        attemptId,
+        slotState: slot?.state ?? "missing",
+        nativeTurnPhase: slot?.nativeTurnPhase ?? "unknown",
+        harnessSessionPresent: Boolean(slot?.harnessSessionId),
+        operationalState: operational?.operationalState ?? "missing"
+      });
+      const row = ("taskId" in decision ? sortedTasks.find((candidate) => candidate.taskId === decision.taskId) : firstTask) ?? firstTask;
+      if (decision.kind === "idle" || decision.kind === "blocked" || decision.kind === "wait") {
+        if (decision.kind === "blocked") {
+          logNativeDeliverySkip(role, row.chatroomId, decision.taskId, decision.reason);
+        }
+        continue;
+      }
+      if (decision.kind === "deduplicated") {
+        logNativeDeliverySkip(role, row.chatroomId, decision.taskId, decision.reason);
+        continue;
+      }
+      if (decision.kind === "start-agent") {
+        if (!row.agentConfig.workingDir || slot && !isSlotIdle(slot.state))
+          continue;
+        try {
+          if (executors) {
+            const startResult2 = await executors.startAgent(row, operational?.operationalState);
+            console.log(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=start-agent result=${startResult2 && typeof startResult2 === "object" && "success" in startResult2 ? startResult2.success : "completed"}`);
+            continue;
+          }
+          const startResult = await params.runSerializedForAgent({ chatroomId: row.chatroomId, role }, { timeoutMs: 120000 }, (ops, context5) => ops.startAgent({
+            chatroomId: row.chatroomId,
+            role,
+            agentHarness: row.agentConfig.agentHarness,
+            model: row.agentConfig.model ?? "",
+            workingDir: row.agentConfig.workingDir,
+            reason: operational?.operationalState === "running" ? AgentStartReasonEnum["platform.task_monitor_nudge"] : AgentStartReasonEnum["platform.pending_task_wake"],
+            wantResume: false,
+            lifecycleRevision: row.agentConfig.configLifecycleRevision,
+            taskId: row.taskId
+          }, context5.signal));
+          console.log(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=start-agent result=${startResult && typeof startResult === "object" && "success" in startResult ? startResult.success : "completed"}`);
+        } catch (error) {
+          console.warn(`[NativeDelivery:failure] role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=start-agent error=${getErrorMessage(error)}`);
+        }
+        continue;
+      }
+      if (!deliveryState.tryAcquireDelivery(row.chatroomId, role)) {
+        logNativeDeliveryMutexSkip(role, row.chatroomId, row.taskId);
+        continue;
+      }
+      const harnessSessionId = decision.harnessSessionId;
+      logNativeDeliveryInjecting(role, row.chatroomId, row.taskId);
+      if (executors) {
+        try {
+          const result = await executors.injectTask(row, harnessSessionId);
+          if (result.kind === "task-unavailable") {
+            console.warn(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject result=task_hydration_missing`);
+          } else if (result.delivered) {
+            onTaskDelivered?.(result.delivered);
+            deliveryState.clearNativeNudgeFailures(row.chatroomId, role);
+            console.log(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject result=success`);
+          }
+        } catch (error) {
+          console.warn(`[NativeDelivery:failure] role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject error=${getErrorMessage(error)}`);
+        } finally {
+          deliveryState.releaseDelivery(row.chatroomId, role);
+        }
+        continue;
+      }
+      await exports_Runtime.runPromise(runtime4)(exports_Effect.gen(function* () {
+        const backend2 = yield* exports_Effect.tryPromise(() => sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
+          sessionId: sessionDeps.sessionId,
+          machineId,
+          taskId: row.taskId,
+          role: row.agentConfig.role
+        }));
+        if (!backend2) {
+          console.warn(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject result=task_hydration_missing`);
+          return;
+        }
+        const full = mapAssignedTaskView(backend2);
+        yield* exports_Effect.tryPromise(() => taskService.deliverNativeTask(full, harnessSessionId, (delivered) => {
+          onTaskDelivered?.(delivered);
+          deliveryState.clearNativeNudgeFailures(delivered.chatroomId, delivered.role);
+          console.log(`[NativeDelivery:execution] attempt=${attemptId} role=${delivered.role} chatroom=${delivered.chatroomId} task=${delivered.taskId} operation=inject result=success`);
+        }));
+      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeDelivery:failure] role=${row.agentConfig.role} chatroom=${row.chatroomId} task=${row.taskId} operation=inject error=${getErrorMessage(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => {
+        deliveryState.releaseDelivery(row.chatroomId, row.agentConfig.role);
+      }))));
+    }
+  }
+}
+function getNativeTaskDeliveryCoordinator() {
+  coordinator ??= new NativeTaskDeliveryCoordinator;
+  return coordinator;
+}
+function resetRoleDeliveryState(chatroomId, role) {
+  getRoleDeliveryState().resetDeliveryState(chatroomId, role);
+}
+var coordinator;
+var init_native_task_delivery_coordinator = __esm(() => {
+  init_agent();
+  init_esm();
+  init_delivery_decision();
+  init_api3();
+  init_convex_error();
+  init_check_agent_slot();
+  init_restart_orchestrator_in_flight();
+});
+
+// src/daemon/services/task-service/service/native-delivery/task-delivery-processor.ts
+async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSerializedForAgent, taskService, sessionDeps, machineId, pass, lifecycleOutbox, operationalModel, isTaskActive, options) {
+  const first = options.snapshots[0];
+  if (!first)
+    return;
+  logNativeDeliveryTrigger(pass, first.agentConfig.role, first.chatroomId, first.taskId);
+  const executors = {
+    startAgent: (task, operationalState) => runSerializedForAgent({ chatroomId: task.chatroomId, role: task.agentConfig.role }, { timeoutMs: 120000 }, (ops, context5) => ops.startAgent({
+      chatroomId: task.chatroomId,
+      role: task.agentConfig.role,
+      agentHarness: task.agentConfig.agentHarness,
+      model: task.agentConfig.model ?? "",
+      workingDir: task.agentConfig.workingDir,
+      reason: operationalState === "running" ? AgentStartReasonEnum["platform.task_monitor_nudge"] : AgentStartReasonEnum["platform.pending_task_wake"],
+      wantResume: false,
+      lifecycleRevision: task.agentConfig.configLifecycleRevision,
+      taskId: task.taskId
+    }, context5.signal)),
+    injectTask: async (task, harnessSessionId) => {
+      const backend2 = await sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
+        sessionId: sessionDeps.sessionId,
+        machineId,
+        taskId: task.taskId,
+        role: task.agentConfig.role
+      });
+      if (!backend2)
+        return { kind: "task-unavailable" };
+      const full = mapAssignedTaskView(backend2);
+      let delivered;
+      await taskService.deliverNativeTask(full, harnessSessionId, (result) => {
+        delivered = result;
+      });
+      return { kind: "delivered", ...delivered ? { delivered } : {} };
+    }
+  };
+  await getNativeTaskDeliveryCoordinator().reconcileRoleTasks({
+    tasks: [...options.snapshots],
+    pass,
+    runtime: runtime4,
+    effectContext: effectContext2,
+    agentMgr,
+    runSerializedForAgent,
+    taskService,
+    sessionDeps,
+    lifecycleOutbox,
+    operationalModel,
+    isTaskActive,
+    machineId,
+    onTaskDelivered: options.onTaskDelivered,
+    executors
+  });
+}
+var init_task_delivery_processor = __esm(() => {
+  init_agent();
+  init_native_task_delivery_coordinator();
+  init_api3();
+});
+
+// src/daemon/services/task-service/service/native-delivery/native-delivery-service.ts
+class NativeDeliveryService {
+  deps;
+  unsubscribeAgentTurnEnded;
+  unsubscribeAgentStarted;
+  unsubscribeAgentSessionLost;
+  reconcileStates = new Map;
+  unsubscribeTaskService;
+  periodicReconcileTimer;
+  periodicReconcileInFlight = false;
+  constructor(deps) {
+    this.deps = deps;
+    this.unsubscribeAgentTurnEnded = deps.agentMgr.subscribeAgentTurnEnded((event) => this.handleAgentTurnEnded(event));
+    this.unsubscribeAgentStarted = deps.agentMgr.subscribeAgentStarted((event) => this.handleAgentStarted(event));
+    this.unsubscribeAgentSessionLost = deps.agentMgr.subscribeAgentSessionLost((event) => this.handleAgentSessionLost(event));
+    this.unsubscribeTaskService = deps.taskService.subscribe?.((notification) => this.handleTaskServiceNotification(notification));
+  }
+  async handleAgentStarted(event) {
+    await this.requestReconcile({
+      chatroomId: event.chatroomId,
+      role: event.role,
+      source: "agent-started"
+    });
+  }
+  handleAgentSessionLost(event) {
+    getRoleDeliveryState().resetDeliveryState(event.chatroomId, event.role);
+    this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+    this.requestReconcile({
+      chatroomId: event.chatroomId,
+      role: event.role,
+      source: "operational-signal"
+    }).catch((error) => {
+      console.warn(`[NativeDelivery:failure] role=${event.role} chatroom=${event.chatroomId} operation=session-loss-reconcile error=${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
+  async handleAgentTurnEnded(event) {
+    this.scheduleRoleDelivery(event.chatroomId, event.role);
+  }
+  scheduleRoleDelivery(chatroomId, role) {
+    setTimeout(() => {
+      this.requestReconcile({ chatroomId, role, source: "turn-ended" }).catch((error) => {
+        console.warn(`[NativeDelivery] post-turn delivery failed for ${role}@${chatroomId}: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }, 0);
+  }
+  dispose() {
+    this.unsubscribeAgentTurnEnded();
+    this.unsubscribeAgentStarted();
+    this.unsubscribeAgentSessionLost();
+    this.unsubscribeTaskService?.();
+    this.unsubscribeTaskService = undefined;
+    if (this.periodicReconcileTimer) {
+      clearInterval(this.periodicReconcileTimer);
+      this.periodicReconcileTimer = undefined;
+    }
+  }
+  startPeriodicReconciliation(intervalMs = NATIVE_DELIVERY_RECONCILE_MS) {
+    if (this.periodicReconcileTimer)
+      return;
+    this.periodicReconcileTimer = setInterval(() => {
+      if (this.periodicReconcileInFlight)
+        return;
+      this.periodicReconcileInFlight = true;
+      const roleKeys = new Set(this.deps.taskSnapshotState.listAll().map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
+      Promise.all([...roleKeys].map((key) => {
+        const separator = key.indexOf(":");
+        return this.requestReconcile({
+          chatroomId: key.slice(0, separator),
+          role: key.slice(separator + 1),
+          source: "periodic-reconcile"
+        });
+      })).catch((error) => {
+        console.warn("[TaskService] local delivery reconciliation failed:", error);
+      }).finally(() => {
+        this.periodicReconcileInFlight = false;
+      });
+    }, intervalMs);
+    this.periodicReconcileTimer.unref?.();
+  }
+  get agentTaskState() {
+    return this.deps.agentTaskState;
+  }
+  async handleTaskInboxUpdate(update5) {
+    await this.requestReconcileForSnapshots(update5.snapshots, "task-signal");
+  }
+  async handleTaskServiceNotification(notification) {
+    if (notification.kind === "bootstrap") {
+      await this.requestReconcileForSnapshots(notification.snapshots, "bootstrap");
+      return;
+    }
+    await this.handleTaskInboxUpdate(notification.update);
+  }
+  async requestReconcile(params) {
+    const key = `${params.chatroomId}:${params.role.toLowerCase()}`;
+    const existing = this.reconcileStates.get(key);
+    if (existing) {
+      existing.pendingSource = params.source;
+      await existing.promise;
+      return;
+    }
+    const state = {
+      pendingSource: undefined,
+      promise: Promise.resolve()
+    };
+    state.promise = (async () => {
+      try {
+        do {
+          const source = state.pendingSource ?? params.source;
+          state.pendingSource = undefined;
+          const snapshots = this.deps.taskSnapshotState.listForRole(params.chatroomId, params.role);
+          if (snapshots.length === 0) {
+            logNativeDeliveryDecision(source, params.role, params.chatroomId, "idle", undefined, {
+              reason: "no_deliverable_task",
+              attemptId: `${Date.now()}-${params.chatroomId}-${params.role}`
+            });
+          }
+          await this.reconcileRole(source, snapshots, params.onTaskDelivered);
+        } while (state.pendingSource !== undefined);
+      } finally {
+        if (this.reconcileStates.get(key) === state)
+          this.reconcileStates.delete(key);
+      }
+    })();
+    this.reconcileStates.set(key, state);
+    await state.promise;
+  }
+  async requestReconcileForSnapshots(snapshots, source) {
+    const roles = new Set(snapshots.map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
+    await Promise.all([...roles].map((key) => {
+      const separator = key.indexOf(":");
+      return this.requestReconcile({
+        chatroomId: key.slice(0, separator),
+        role: key.slice(separator + 1),
+        source
+      });
+    }));
+  }
+  async reconcileRole(pass, snapshots, onTaskDelivered) {
+    if (snapshots.length === 0)
+      return;
+    await processTasksUpdate(this.deps.runtime, this.deps.effectContext, this.deps.agentMgr, this.deps.runSerializedForAgent, this.deps.taskService, this.deps.sessionDeps, this.deps.machineId, pass, this.deps.lifecycleOutbox, this.deps.agentOperationalReadModel, ({ chatroomId, role, taskId }) => this.deps.agentTaskState.get({ chatroomId, role })?.taskId === taskId, {
+      snapshots,
+      onTaskDelivered: (args2) => {
+        this.recordTaskDelivered(args2);
+        onTaskDelivered?.(args2);
+      }
+    });
+  }
+  recordTaskDelivered(args2) {
+    this.deps.agentTaskState.start(args2);
+  }
+}
+var NATIVE_DELIVERY_RECONCILE_MS = 1e4;
+var init_native_delivery_service = __esm(() => {
+  init_task_delivery_processor();
+});
+
 // src/daemon/services/task-service/service/task-outbox.ts
 class TaskOutbox {
   sender;
@@ -46535,42 +47125,6 @@ var init_assigned_task_snapshot_contract = __esm(() => {
   }));
 });
 
-// src/infrastructure/mappers/map-assigned-task.ts
-function mapAssignedTaskSnapshot(row) {
-  return {
-    taskId: row.taskId,
-    chatroomId: row.chatroomId,
-    status: row.status,
-    assignedTo: row.assignedTo,
-    updatedAt: row.updatedAt,
-    createdAt: row.createdAt,
-    agentConfig: {
-      role: row.agentConfig.role,
-      machineId: row.agentConfig.machineId,
-      agentHarness: row.agentConfig.agentHarness,
-      model: row.agentConfig.model,
-      workingDir: row.agentConfig.workingDir,
-      spawnedAgentPid: row.agentConfig.spawnedAgentPid,
-      desiredState: row.agentConfig.desiredState,
-      circuitState: row.agentConfig.circuitState,
-      configLifecycleRevision: row.agentConfig.configLifecycleRevision
-    },
-    participant: row.participant,
-    requestsNativeColdSession: row.requestsNativeColdSession
-  };
-}
-function mapAssignedTaskView(row) {
-  return {
-    ...mapAssignedTaskSnapshot(row),
-    taskContent: row.taskContent,
-    taskEnvelope: row.taskEnvelope,
-    startInNewSession: row.startInNewSession
-  };
-}
-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, {
@@ -47025,7 +47579,7 @@ function createTaskService(deps) {
     roomControllers.set(chatroomId, controller);
     runRoomInbox(chatroomId, cursor, controller);
   };
-  return {
+  const service4 = {
     startTaskInbox: async (client2) => {
       if (inboxClient)
         return;
@@ -47075,11 +47629,22 @@ function createTaskService(deps) {
     deliverNativeTask: (task, harnessSessionId, onTaskDelivered) => taskOutbox.enqueue({ task, harnessSessionId, onTaskDelivered }),
     isNativeHarness,
     snapshotRequestsNativeColdSession,
-    explainNativeDeliveryBlock: (task, options) => explainNativeDeliveryBlock(task, options)
+    explainNativeDeliveryBlock: (task, options) => explainNativeDeliveryBlock(task, options),
+    createNativeDeliveryService: (deliveryDeps) => {
+      const nativeDelivery = new NativeDeliveryService({
+        ...deliveryDeps,
+        taskSnapshotState,
+        taskService: service4
+      });
+      nativeDelivery.startPeriodicReconciliation();
+      return nativeDelivery;
+    }
   };
+  return service4;
 }
 var init_task_service = __esm(() => {
   init_esm();
+  init_native_delivery_service();
   init_native_task_injector();
   init_api3();
   init_fetch_machine_assigned_task_snapshots();
@@ -47098,6 +47663,10 @@ var init_task_service2 = __esm(() => {
   init_native_ready_invariant();
   init_native_cold_session_delivery();
   init_task_service();
+  init_convex_native_task_delivery_gateway();
+  init_daemon_audit_port();
+  init_native_delivery_service();
+  init_native_task_delivery_coordinator();
 });
 
 // src/daemon/services/service-interfaces.ts
@@ -47109,8 +47678,10 @@ __export(exports_service_interfaces, {
   shouldDeliverNativeTask: () => shouldDeliverNativeTask,
   setNativeTurnPhase: () => setNativeTurnPhase,
   runRoleScopedStop: () => runRoleScopedStop,
+  runNativeInjectionEffect: () => runNativeInjectionEffect,
   runExactTargetsStop: () => runExactTargetsStop,
   runConfirmedStop: () => runConfirmedStop,
+  resetRoleDeliveryState: () => resetRoleDeliveryState,
   resetChatroomScopeBarrierForTests: () => resetChatroomScopeBarrierForTests,
   reapOrphanedProcessGroupsEffect: () => reapOrphanedProcessGroupsEffect,
   reapOrphanedProcessGroups: () => reapOrphanedProcessGroups,
@@ -47130,6 +47701,8 @@ __export(exports_service_interfaces, {
   createStopAgentTargetsDeps: () => createStopAgentTargetsDeps,
   createStopAgentConfirmedDeps: () => createStopAgentConfirmedDeps,
   createHarnessActivityEmitter: () => createHarnessActivityEmitter,
+  createDaemonAuditPort: () => createDaemonAuditPort,
+  createConvexNativeTaskDeliveryGateway: () => createConvexNativeTaskDeliveryGateway,
   createChatroomScopeBarrier: () => createChatroomScopeBarrier,
   createAgentTaskStateService: () => createAgentTaskStateService,
   createAgentProcessService: () => createAgentProcessService,
@@ -47140,6 +47713,7 @@ __export(exports_service_interfaces, {
   buildStopTargetDescriptor: () => buildStopTargetDescriptor,
   buildNativeInjectionPrompt: () => buildNativeInjectionPrompt,
   STOPPING_TIMEOUT_MS: () => STOPPING_TIMEOUT_MS,
+  NativeDeliveryService: () => NativeDeliveryService,
   InMemoryActiveTaskStateStore: () => InMemoryActiveTaskStateStore,
   HARNESS_ACTIVITY_KINDS: () => HARNESS_ACTIVITY_KINDS,
   DefaultAgentTaskStateService: () => DefaultAgentTaskStateService,
@@ -110113,6 +110687,346 @@ var init_command_sync_heartbeat = __esm(() => {
   });
 });
 
+// src/daemon/entry/refresh-models-outcome.ts
+function capabilitiesOutcomeToStatus(outcome) {
+  switch (outcome.kind) {
+    case "pushed":
+      return { status: "completed" };
+    case "skipped_no_changes":
+      return { status: "skipped_no_changes" };
+    case "failed":
+      return { status: "failed", errorMessage: outcome.message };
+    case "noop":
+      return { status: "failed", errorMessage: "Daemon configuration unavailable" };
+    default: {
+      const _exhaustive = outcome;
+      return _exhaustive;
+    }
+  }
+}
+var init_refresh_models_outcome = () => {};
+
+// src/daemon/entry/resolve-local-web-port.ts
+function resolveDefaultLocalWebPort(convexUrl = getConvexUrl()) {
+  return isProductionConvexUrl(convexUrl) ? PRODUCTION_LOCAL_WEB_PORT : NON_PRODUCTION_LOCAL_WEB_PORT;
+}
+function resolveLocalWebPort(env2 = process.env, convexUrl = getConvexUrl()) {
+  const override = env2.CHATROOM_LOCAL_WEB_PORT;
+  if (override !== undefined && override !== "") {
+    return Number(override);
+  }
+  return resolveDefaultLocalWebPort(convexUrl);
+}
+var PRODUCTION_LOCAL_WEB_PORT = 18765, NON_PRODUCTION_LOCAL_WEB_PORT = 28765;
+var init_resolve_local_web_port = __esm(() => {
+  init_env();
+  init_client2();
+});
+
+// src/daemon/infrastructure/git/git-writer.ts
+function classifyError2(errMessage) {
+  return { status: "error", message: errMessage.trim() };
+}
+async function discardFile(workingDir, filePath) {
+  const result = await runGit(["checkout", "--", filePath], workingDir);
+  if ("error" in result) {
+    return classifyError2(result.error.message);
+  }
+  return { status: "available" };
+}
+async function discardAllChanges(workingDir) {
+  const checkoutResult = await runGit(["checkout", "--", "."], workingDir);
+  if ("error" in checkoutResult) {
+    return classifyError2(checkoutResult.error.message);
+  }
+  const cleanResult = await runGit(["clean", "-fd"], workingDir);
+  if ("error" in cleanResult) {
+    return classifyError2(cleanResult.error.message);
+  }
+  return { status: "available" };
+}
+async function gitPull(workingDir) {
+  const result = await runGit(["pull"], workingDir);
+  if ("error" in result) {
+    const message = result.error.message;
+    if (message.includes("no tracking branch")) {
+      return {
+        status: "error",
+        message: "No tracking branch configured. Set upstream with `git push -u`."
+      };
+    }
+    if (message.includes("conflict")) {
+      return { status: "error", message: "Merge conflict detected. Resolve conflicts manually." };
+    }
+    if (message.includes("Authentication failed") || message.includes("could not read")) {
+      return {
+        status: "error",
+        message: "Authentication failed. Run `gh auth status` to check your GitHub credentials."
+      };
+    }
+    return classifyError2(message);
+  }
+  const stderr = result.stderr.trim();
+  if (stderr && !stderr.includes("Already up to date")) {
+    return { status: "available", message: stderr };
+  }
+  return { status: "available" };
+}
+async function gitPush(workingDir) {
+  const result = await runGit(["push"], workingDir);
+  if ("error" in result) {
+    const message = result.error.message;
+    if (message.includes("no upstream branch")) {
+      return {
+        status: "error",
+        message: "No upstream branch configured. Set upstream with `git push -u`."
+      };
+    }
+    if (message.includes("Authentication failed") || message.includes("could not read")) {
+      return {
+        status: "error",
+        message: "Authentication failed. Run `gh auth status` to check your GitHub credentials."
+      };
+    }
+    return classifyError2(message);
+  }
+  const stderr = result.stderr.trim();
+  if (stderr && !stderr.includes("Everything up-to-date")) {
+    return { status: "available", message: stderr };
+  }
+  return { status: "available" };
+}
+async function gitSync(workingDir) {
+  const pullResult = await gitPull(workingDir);
+  if (pullResult.status === "error") {
+    return pullResult;
+  }
+  return gitPush(workingDir);
+}
+var init_git_writer = __esm(() => {
+  init_run_command();
+});
+
+// src/daemon/infrastructure/git/index.ts
+var init_git = __esm(() => {
+  init_git_reader();
+  init_git_writer();
+});
+
+// src/infrastructure/local-actions/execute-local-action.ts
+import { spawn as spawn5 } from "node:child_process";
+import { access as access3 } from "node:fs/promises";
+function escapeShellArg(arg) {
+  return `"${arg.replace(/"/g, "\\\"")}"`;
+}
+function resolveWhichCommand(name) {
+  return process.platform === "win32" ? `where ${name}` : `which ${name}`;
+}
+function isCliAvailable(cliName) {
+  return new Promise((resolve5) => {
+    const child = spawn5(resolveWhichCommand(cliName), [], DETACHED_SHELL_SPAWN_OPTIONS);
+    child.on("error", () => resolve5(false));
+    child.on("close", (code2) => resolve5(code2 === 0));
+    child.unref();
+  });
+}
+function execFireAndForget(command, logTag) {
+  const child = spawn5(command, [], DETACHED_SHELL_SPAWN_OPTIONS);
+  child.on("error", (err) => {
+    console.warn(`[${logTag}] spawn failed: ${err.message}`);
+  });
+  child.unref();
+}
+function resolveOpenCommand(platform) {
+  switch (platform) {
+    case "darwin":
+      return "open";
+    case "win32":
+      return "explorer";
+    default:
+      return "xdg-open";
+  }
+}
+function resolveOpenUrlCommand(platform) {
+  return platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+}
+async function openVscode(workingDir) {
+  const available = await isCliAvailable("code");
+  if (!available) {
+    return {
+      success: false,
+      error: "VS Code CLI (code) not found. Install via: VS Code → Cmd+Shift+P → 'Shell Command: Install code in PATH'"
+    };
+  }
+  execFireAndForget(`code ${escapeShellArg(workingDir)}`, "open-vscode");
+  return { success: true };
+}
+async function openFinder(workingDir) {
+  const cmd = resolveOpenCommand(process.platform);
+  execFireAndForget(`${cmd} ${escapeShellArg(workingDir)}`, "open-finder");
+  return { success: true };
+}
+async function openCursor(workingDir) {
+  const available = await isCliAvailable("cursor");
+  if (!available) {
+    return {
+      success: false,
+      error: "Cursor CLI (cursor) not found. Install via: Cursor → Cmd+Shift+P → 'Shell Command: Install cursor in PATH'"
+    };
+  }
+  execFireAndForget(`cursor ${escapeShellArg(workingDir)}`, "open-cursor");
+  return { success: true };
+}
+async function openGithubDesktop(workingDir) {
+  const available = await isCliAvailable("github");
+  if (!available) {
+    return { success: false, error: "GitHub Desktop CLI not found" };
+  }
+  execFireAndForget(`github ${escapeShellArg(workingDir)}`, "open-github-desktop");
+  return { success: true };
+}
+async function openDaemonLogs(_workingDir, options) {
+  const params = new URLSearchParams;
+  if (options?.chatroomId)
+    params.set("chatroomId", options.chatroomId);
+  const qs = params.toString();
+  const url3 = `http://127.0.0.1:${resolveLocalWebPort()}/${qs ? `?${qs}` : ""}`;
+  execFireAndForget(`${resolveOpenUrlCommand(process.platform)} ${escapeShellArg(url3)}`, "open-daemon-logs");
+  return { success: true };
+}
+async function gitDiscardFileAction(workingDir) {
+  const separatorIndex = workingDir.indexOf("::");
+  if (separatorIndex === -1) {
+    return {
+      success: false,
+      error: 'Invalid file path. Expected format: "/path/to/dir::/path/to/file"'
+    };
+  }
+  const dir = workingDir.slice(0, separatorIndex);
+  const filePath = workingDir.slice(separatorIndex + 2);
+  const result = await discardFile(dir, filePath);
+  if (result.status === "error") {
+    return { success: false, error: result.message };
+  }
+  return { success: true };
+}
+async function gitDiscardAllAction(workingDir) {
+  const result = await discardAllChanges(workingDir);
+  if (result.status === "error") {
+    return { success: false, error: result.message };
+  }
+  return { success: true };
+}
+async function gitPullAction(workingDir) {
+  const result = await gitPull(workingDir);
+  if (result.status === "error") {
+    return { success: false, error: result.message };
+  }
+  return { success: true, message: result.message ?? "Pull successful" };
+}
+async function gitPushAction(workingDir) {
+  const result = await gitPush(workingDir);
+  if (result.status === "error") {
+    return { success: false, error: result.message };
+  }
+  return { success: true, message: result.message ?? "Push successful" };
+}
+async function gitSyncAction(workingDir) {
+  const result = await gitSync(workingDir);
+  if (result.status === "error") {
+    return { success: false, error: result.message };
+  }
+  return { success: true, message: result.message ?? "Sync successful" };
+}
+async function executeLocalAction(action, workingDir, options) {
+  if (action === "open-daemon-logs")
+    return openDaemonLogs(workingDir, options);
+  try {
+    await access3(workingDir);
+  } catch {
+    return { success: false, error: `Directory not found: ${workingDir}` };
+  }
+  const handler2 = actionHandlers[action];
+  if (handler2)
+    return handler2(workingDir);
+  return { success: false, error: `Unknown action: ${action}` };
+}
+var DETACHED_SHELL_SPAWN_OPTIONS, actionHandlers;
+var init_execute_local_action = __esm(() => {
+  init_resolve_local_web_port();
+  init_git();
+  DETACHED_SHELL_SPAWN_OPTIONS = {
+    stdio: "ignore",
+    detached: true,
+    shell: true
+  };
+  actionHandlers = {
+    "open-vscode": openVscode,
+    "open-finder": openFinder,
+    "open-cursor": openCursor,
+    "open-github-desktop": openGithubDesktop,
+    "open-daemon-logs": openDaemonLogs,
+    "git-discard-file": gitDiscardFileAction,
+    "git-discard-all": gitDiscardAllAction,
+    "git-pull": gitPullAction,
+    "git-push": gitPushAction,
+    "git-sync": gitSyncAction
+  };
+});
+
+// src/infrastructure/local-actions/index.ts
+var init_local_actions = __esm(() => {
+  init_execute_local_action();
+});
+
+// src/infrastructure/local-actions/pick-folder.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+function runPicker(command, args2) {
+  try {
+    const path3 = execFileSync2(command, args2, { encoding: "utf8", timeout: 300000 }).trim();
+    if (!path3)
+      return { success: false, error: "No folder selected" };
+    return { success: true, path: path3 };
+  } catch (error51) {
+    const exitCode = typeof error51 === "object" && error51 !== null && "status" in error51 ? error51.status : null;
+    if (exitCode === 1)
+      return { success: false, error: "Cancelled", cancelled: true };
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    return { success: false, error: message };
+  }
+}
+function pickFolderDialog() {
+  switch (process.platform) {
+    case "darwin":
+      return runPicker("osascript", [
+        "-e",
+        'POSIX path of (choose folder with prompt "Select workspace folder")'
+      ]);
+    case "win32":
+      return runPicker("powershell", [
+        "-NoProfile",
+        "-Command",
+        [
+          "Add-Type -AssemblyName System.Windows.Forms",
+          "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
+          '$dialog.Description = "Select workspace folder"',
+          "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+          "  Write-Output $dialog.SelectedPath",
+          "  exit 0",
+          "}",
+          "exit 1"
+        ].join("; ")
+      ]);
+    default:
+      return runPicker("zenity", [
+        "--file-selection",
+        "--directory",
+        "--title=Select workspace folder"
+      ]);
+  }
+}
+var init_pick_folder = () => {};
+
 // src/daemon/domain/usecase/restart-agent.ts
 async function restartAgent(deps, input) {
   const now = deps.now?.() ?? Date.now();
@@ -110134,7 +111048,9 @@ async function restartAgent(deps, input) {
       wantResume: input.wantResume,
       ...input.lifecycleRevision !== undefined ? { lifecycleRevision: input.lifecycleRevision } : {}
     });
-  } catch {}
+  } catch (error51) {
+    log4(`[daemon] agent.restart failed (correlationId=${input.correlationId}) for role=${input.role}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  }
 }
 
 // ../../services/backend/src/domain/usecase/agent/build-agent-restart-event.ts
@@ -110165,200 +111081,6 @@ var init_build_agent_restart_event = __esm(() => {
   init_reliability();
 });
 
-// src/daemon/infrastructure/agent-operational/fetch-machine-agent-operational-status.ts
-async function fetchMachineAgentOperationalStatus(sessionDeps, machineId) {
-  const result = await sessionDeps.backend.query(api.machines.listMachineAgentOperationalStatus, {
-    sessionId: sessionDeps.sessionId,
-    machineId
-  });
-  return result;
-}
-var init_fetch_machine_agent_operational_status = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/entry/native-delivery/native-delivery-log.ts
-function logNativeDeliveryTrigger(source, role, chatroomId, taskId) {
-  const taskSuffix = taskId ? ` task ${taskId}` : "";
-  console.log(`[NativeDelivery:trigger] source=${source} ${role}@${chatroomId}${taskSuffix}`);
-}
-function logNativeDeliveryFallback(reason, role, chatroomId, taskId) {
-  const taskSuffix = taskId ? ` task ${taskId}` : "";
-  console.log(`[NativeDelivery:fallback] source=${reason} ${role}@${chatroomId}${taskSuffix} — periodic recovery pass`);
-}
-function logNativeDeliverySkip(role, chatroomId, taskId, reason) {
-  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — ${reason}`);
-}
-function logNativeDeliveryMutexSkip(role, chatroomId, taskId) {
-  console.log(`[NativeDelivery:skip] ${role}@${chatroomId} task ${taskId} — delivery_mutex_busy (another inject in flight)`);
-}
-function logNativeDeliveryInjecting(role, chatroomId, taskId) {
-  console.log(`[NativeDelivery:inject] ${role}@${chatroomId} task ${taskId} — starting injection`);
-}
-
-// src/daemon/entry/restart-orchestrator-in-flight.ts
-function roleKey(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
-}
-function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  inFlight.set(roleKey(chatroomId, role), correlationId);
-}
-function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  const key = roleKey(chatroomId, role);
-  if (correlationId !== undefined && inFlight.get(key) !== correlationId)
-    return;
-  inFlight.delete(key);
-}
-function isRestartOrchestratorInFlight(chatroomId, role) {
-  return inFlight.has(roleKey(chatroomId, role));
-}
-function filterSnapshotsExcludingRestartInFlight(snapshots) {
-  return snapshots.filter((row) => !isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role));
-}
-var inFlight;
-var init_restart_orchestrator_in_flight = __esm(() => {
-  inFlight = new Map;
-});
-
-// src/daemon/entry/role-delivery-state.ts
-function roleKey2(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
-}
-
-class RoleDeliveryState {
-  generation = new Map;
-  inFlight = new Set;
-  nativeNudgeFailures = new Map;
-  getGeneration(chatroomId, role) {
-    return this.generation.get(roleKey2(chatroomId, role)) ?? 0;
-  }
-  resetDeliveryState(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
-    const next4 = (this.generation.get(key) ?? 0) + 1;
-    this.generation.set(key, next4);
-    this.inFlight.delete(key);
-    this.nativeNudgeFailures.delete(key);
-    return next4;
-  }
-  tryAcquireDelivery(chatroomId, role) {
-    const key = roleKey2(chatroomId, role);
-    if (this.inFlight.has(key))
-      return false;
-    this.inFlight.add(key);
-    return true;
-  }
-  releaseDelivery(chatroomId, role) {
-    this.inFlight.delete(roleKey2(chatroomId, role));
-  }
-  recordNativeNudgeFailure(chatroomId, role) {
-    const key = roleKey2(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));
-  }
-  getNativeNudgeFailures(chatroomId, role) {
-    return this.nativeNudgeFailures.get(roleKey2(chatroomId, role)) ?? 0;
-  }
-}
-function getRoleDeliveryState() {
-  shared ??= new RoleDeliveryState;
-  return shared;
-}
-var shared;
-
-// src/daemon/entry/native-delivery/native-task-delivery-coordinator.ts
-class NativeTaskDeliveryCoordinator {
-  resetRoleDeliveryState(chatroomId, role) {
-    getRoleDeliveryState().resetDeliveryState(chatroomId, role);
-  }
-  async reconcileAssignedTasks(params) {
-    const tasks = filterSnapshotsExcludingRestartInFlight(params.tasks);
-    if (tasks.length === 0)
-      return;
-    const {
-      runtime: runtime4,
-      effectContext: effectContext2,
-      agentMgr,
-      sessionDeps,
-      operationalModel,
-      isTaskActive,
-      machineId,
-      onTaskDelivered
-    } = params;
-    const deliveryState = getRoleDeliveryState();
-    const taskService = params.taskService;
-    const pendingFirst = [...tasks].sort((a, b) => {
-      if (a.status === "pending" && b.status !== "pending")
-        return -1;
-      if (b.status === "pending" && a.status !== "pending")
-        return 1;
-      return a.createdAt - b.createdAt;
-    });
-    for (const row of pendingFirst) {
-      const { role } = row.agentConfig;
-      const slot = agentMgr.getSlot(row.chatroomId, role);
-      const blockReason = taskService.explainNativeDeliveryBlock(row, {
-        slot,
-        operational: operationalModel.get(row.chatroomId, role)
-      });
-      if (blockReason) {
-        if (isDeliverableTaskStatus(row.status)) {
-          logNativeDeliverySkip(role, row.chatroomId, row.taskId, blockReason);
-        }
-        continue;
-      }
-      if (isTaskActive({ chatroomId: row.chatroomId, role, taskId: row.taskId })) {
-        logNativeDeliverySkip(role, row.chatroomId, row.taskId, "task_state_active");
-        continue;
-      }
-      const harnessSessionId = slot?.harnessSessionId;
-      if (!deliveryState.tryAcquireDelivery(row.chatroomId, role)) {
-        logNativeDeliveryMutexSkip(role, row.chatroomId, row.taskId);
-        continue;
-      }
-      logNativeDeliveryInjecting(role, row.chatroomId, row.taskId);
-      await exports_Runtime.runPromise(runtime4)(exports_Effect.gen(function* () {
-        const backend2 = yield* exports_Effect.tryPromise(() => sessionDeps.backend.query(api.machines.getAssignedTaskForAction, {
-          sessionId: sessionDeps.sessionId,
-          machineId,
-          taskId: row.taskId,
-          role: row.agentConfig.role
-        }));
-        if (!backend2) {
-          console.warn(`[NativeDelivery:skip] ${role}@${row.chatroomId} task ${row.taskId} — task_hydrate_missing (deleted or not assigned)`);
-          return;
-        }
-        const full = mapAssignedTaskView(backend2);
-        yield* exports_Effect.tryPromise(() => taskService.deliverNativeTask(full, harnessSessionId, (delivered) => {
-          onTaskDelivered?.(delivered);
-          deliveryState.clearNativeNudgeFailures(delivered.chatroomId, delivered.role);
-        }));
-      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${row.agentConfig.role}@${row.chatroomId}: ${getErrorMessage(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => {
-        deliveryState.releaseDelivery(row.chatroomId, row.agentConfig.role);
-      }))));
-      break;
-    }
-  }
-}
-function getNativeTaskDeliveryCoordinator() {
-  coordinator ??= new NativeTaskDeliveryCoordinator;
-  return coordinator;
-}
-function resetRoleDeliveryState(chatroomId, role) {
-  getRoleDeliveryState().resetDeliveryState(chatroomId, role);
-}
-var coordinator;
-var init_native_task_delivery_coordinator = __esm(() => {
-  init_esm();
-  init_api3();
-  init_assigned_task();
-  init_convex_error();
-  init_restart_orchestrator_in_flight();
-});
-
 // src/daemon/entry/restart-orchestrator.ts
 async function emitPhase(deps, event, phase, detail) {
   const now = Date.now();
@@ -110399,31 +111121,22 @@ async function forceNativeWaiting(deps, event) {
     action: NATIVE_WAITING_ACTION
   });
 }
-async function listDeliverableSnapshots(deps, event) {
+async function syncAssignedTaskSnapshots(deps) {
   await deps.session.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
     sessionId: deps.session.sessionId,
     machineId: deps.session.machineId
   });
-  const result = await deps.session.backend.query(api.machines.listMachineAssignedTaskSnapshots, {
-    sessionId: deps.session.sessionId,
-    machineId: deps.session.machineId
-  });
-  const operationalRows = await fetchMachineAgentOperationalStatus({
-    sessionId: deps.session.sessionId,
-    machineId: deps.session.machineId,
-    convexUrl: deps.session.convexUrl,
-    logEvent: deps.session.logEvent,
-    backend: deps.session.backend
-  }, deps.session.machineId);
-  const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
-  const operational = operationalRows.find((row) => row.chatroomId === event.chatroomId && row.role.toLowerCase() === event.role.toLowerCase());
-  return mapAssignedTaskSnapshotList(parseAssignedTaskSnapshotRows(result.tasks ?? [])).filter((t) => t.chatroomId === event.chatroomId && t.agentConfig.role.toLowerCase() === event.role.toLowerCase() && isDeliverableTaskStatus(t.status) && isAgentReadyForNativeDelivery(t, slot, operational)).sort((a, b) => a.createdAt - b.createdAt);
 }
 async function deliverPendingTasks(deps, event) {
   const delivered = [];
-  const snapshots = await listDeliverableSnapshots(deps, event);
-  await deps.nativeDelivery.processSnapshots("restart", snapshots, ({ taskId }) => {
-    delivered.push(taskId);
+  await syncAssignedTaskSnapshots(deps);
+  await deps.nativeDelivery.requestReconcile({
+    chatroomId: event.chatroomId,
+    role: event.role,
+    source: "restart-completed",
+    onTaskDelivered: ({ taskId }) => {
+      delivered.push(taskId);
+    }
   });
   return delivered;
 }
@@ -110479,15 +111192,11 @@ async function runRestartOrchestrator(deps, event) {
 var init_restart_orchestrator = __esm(() => {
   init_reliability();
   init_build_agent_restart_event();
-  init_assigned_task_snapshot_contract();
-  init_fetch_machine_agent_operational_status();
-  init_api3();
-  init_service_interfaces();
-  init_native_task_delivery_coordinator();
   init_restart_orchestrator_in_flight();
+  init_api3();
   init_convex_error();
-  init_assigned_task();
   init_execution_kind();
+  init_service_interfaces();
 });
 
 // src/daemon/entry/bridge/agent-control-bridge.ts
@@ -110814,346 +111523,6 @@ var init_manager = __esm(() => {
   processManager = new ProcessManager;
 });
 
-// src/daemon/entry/refresh-models-outcome.ts
-function capabilitiesOutcomeToStatus(outcome) {
-  switch (outcome.kind) {
-    case "pushed":
-      return { status: "completed" };
-    case "skipped_no_changes":
-      return { status: "skipped_no_changes" };
-    case "failed":
-      return { status: "failed", errorMessage: outcome.message };
-    case "noop":
-      return { status: "failed", errorMessage: "Daemon configuration unavailable" };
-    default: {
-      const _exhaustive = outcome;
-      return _exhaustive;
-    }
-  }
-}
-var init_refresh_models_outcome = () => {};
-
-// src/daemon/entry/resolve-local-web-port.ts
-function resolveDefaultLocalWebPort(convexUrl = getConvexUrl()) {
-  return isProductionConvexUrl(convexUrl) ? PRODUCTION_LOCAL_WEB_PORT : NON_PRODUCTION_LOCAL_WEB_PORT;
-}
-function resolveLocalWebPort(env2 = process.env, convexUrl = getConvexUrl()) {
-  const override = env2.CHATROOM_LOCAL_WEB_PORT;
-  if (override !== undefined && override !== "") {
-    return Number(override);
-  }
-  return resolveDefaultLocalWebPort(convexUrl);
-}
-var PRODUCTION_LOCAL_WEB_PORT = 18765, NON_PRODUCTION_LOCAL_WEB_PORT = 28765;
-var init_resolve_local_web_port = __esm(() => {
-  init_env();
-  init_client2();
-});
-
-// src/daemon/infrastructure/git/git-writer.ts
-function classifyError2(errMessage) {
-  return { status: "error", message: errMessage.trim() };
-}
-async function discardFile(workingDir, filePath) {
-  const result = await runGit(["checkout", "--", filePath], workingDir);
-  if ("error" in result) {
-    return classifyError2(result.error.message);
-  }
-  return { status: "available" };
-}
-async function discardAllChanges(workingDir) {
-  const checkoutResult = await runGit(["checkout", "--", "."], workingDir);
-  if ("error" in checkoutResult) {
-    return classifyError2(checkoutResult.error.message);
-  }
-  const cleanResult = await runGit(["clean", "-fd"], workingDir);
-  if ("error" in cleanResult) {
-    return classifyError2(cleanResult.error.message);
-  }
-  return { status: "available" };
-}
-async function gitPull(workingDir) {
-  const result = await runGit(["pull"], workingDir);
-  if ("error" in result) {
-    const message = result.error.message;
-    if (message.includes("no tracking branch")) {
-      return {
-        status: "error",
-        message: "No tracking branch configured. Set upstream with `git push -u`."
-      };
-    }
-    if (message.includes("conflict")) {
-      return { status: "error", message: "Merge conflict detected. Resolve conflicts manually." };
-    }
-    if (message.includes("Authentication failed") || message.includes("could not read")) {
-      return {
-        status: "error",
-        message: "Authentication failed. Run `gh auth status` to check your GitHub credentials."
-      };
-    }
-    return classifyError2(message);
-  }
-  const stderr = result.stderr.trim();
-  if (stderr && !stderr.includes("Already up to date")) {
-    return { status: "available", message: stderr };
-  }
-  return { status: "available" };
-}
-async function gitPush(workingDir) {
-  const result = await runGit(["push"], workingDir);
-  if ("error" in result) {
-    const message = result.error.message;
-    if (message.includes("no upstream branch")) {
-      return {
-        status: "error",
-        message: "No upstream branch configured. Set upstream with `git push -u`."
-      };
-    }
-    if (message.includes("Authentication failed") || message.includes("could not read")) {
-      return {
-        status: "error",
-        message: "Authentication failed. Run `gh auth status` to check your GitHub credentials."
-      };
-    }
-    return classifyError2(message);
-  }
-  const stderr = result.stderr.trim();
-  if (stderr && !stderr.includes("Everything up-to-date")) {
-    return { status: "available", message: stderr };
-  }
-  return { status: "available" };
-}
-async function gitSync(workingDir) {
-  const pullResult = await gitPull(workingDir);
-  if (pullResult.status === "error") {
-    return pullResult;
-  }
-  return gitPush(workingDir);
-}
-var init_git_writer = __esm(() => {
-  init_run_command();
-});
-
-// src/daemon/infrastructure/git/index.ts
-var init_git = __esm(() => {
-  init_git_reader();
-  init_git_writer();
-});
-
-// src/infrastructure/local-actions/execute-local-action.ts
-import { spawn as spawn5 } from "node:child_process";
-import { access as access3 } from "node:fs/promises";
-function escapeShellArg(arg) {
-  return `"${arg.replace(/"/g, "\\\"")}"`;
-}
-function resolveWhichCommand(name) {
-  return process.platform === "win32" ? `where ${name}` : `which ${name}`;
-}
-function isCliAvailable(cliName) {
-  return new Promise((resolve5) => {
-    const child = spawn5(resolveWhichCommand(cliName), [], DETACHED_SHELL_SPAWN_OPTIONS);
-    child.on("error", () => resolve5(false));
-    child.on("close", (code2) => resolve5(code2 === 0));
-    child.unref();
-  });
-}
-function execFireAndForget(command, logTag) {
-  const child = spawn5(command, [], DETACHED_SHELL_SPAWN_OPTIONS);
-  child.on("error", (err) => {
-    console.warn(`[${logTag}] spawn failed: ${err.message}`);
-  });
-  child.unref();
-}
-function resolveOpenCommand(platform) {
-  switch (platform) {
-    case "darwin":
-      return "open";
-    case "win32":
-      return "explorer";
-    default:
-      return "xdg-open";
-  }
-}
-function resolveOpenUrlCommand(platform) {
-  return platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-}
-async function openVscode(workingDir) {
-  const available = await isCliAvailable("code");
-  if (!available) {
-    return {
-      success: false,
-      error: "VS Code CLI (code) not found. Install via: VS Code → Cmd+Shift+P → 'Shell Command: Install code in PATH'"
-    };
-  }
-  execFireAndForget(`code ${escapeShellArg(workingDir)}`, "open-vscode");
-  return { success: true };
-}
-async function openFinder(workingDir) {
-  const cmd = resolveOpenCommand(process.platform);
-  execFireAndForget(`${cmd} ${escapeShellArg(workingDir)}`, "open-finder");
-  return { success: true };
-}
-async function openCursor(workingDir) {
-  const available = await isCliAvailable("cursor");
-  if (!available) {
-    return {
-      success: false,
-      error: "Cursor CLI (cursor) not found. Install via: Cursor → Cmd+Shift+P → 'Shell Command: Install cursor in PATH'"
-    };
-  }
-  execFireAndForget(`cursor ${escapeShellArg(workingDir)}`, "open-cursor");
-  return { success: true };
-}
-async function openGithubDesktop(workingDir) {
-  const available = await isCliAvailable("github");
-  if (!available) {
-    return { success: false, error: "GitHub Desktop CLI not found" };
-  }
-  execFireAndForget(`github ${escapeShellArg(workingDir)}`, "open-github-desktop");
-  return { success: true };
-}
-async function openDaemonLogs(_workingDir, options) {
-  const params = new URLSearchParams;
-  if (options?.chatroomId)
-    params.set("chatroomId", options.chatroomId);
-  const qs = params.toString();
-  const url3 = `http://127.0.0.1:${resolveLocalWebPort()}/${qs ? `?${qs}` : ""}`;
-  execFireAndForget(`${resolveOpenUrlCommand(process.platform)} ${escapeShellArg(url3)}`, "open-daemon-logs");
-  return { success: true };
-}
-async function gitDiscardFileAction(workingDir) {
-  const separatorIndex = workingDir.indexOf("::");
-  if (separatorIndex === -1) {
-    return {
-      success: false,
-      error: 'Invalid file path. Expected format: "/path/to/dir::/path/to/file"'
-    };
-  }
-  const dir = workingDir.slice(0, separatorIndex);
-  const filePath = workingDir.slice(separatorIndex + 2);
-  const result = await discardFile(dir, filePath);
-  if (result.status === "error") {
-    return { success: false, error: result.message };
-  }
-  return { success: true };
-}
-async function gitDiscardAllAction(workingDir) {
-  const result = await discardAllChanges(workingDir);
-  if (result.status === "error") {
-    return { success: false, error: result.message };
-  }
-  return { success: true };
-}
-async function gitPullAction(workingDir) {
-  const result = await gitPull(workingDir);
-  if (result.status === "error") {
-    return { success: false, error: result.message };
-  }
-  return { success: true, message: result.message ?? "Pull successful" };
-}
-async function gitPushAction(workingDir) {
-  const result = await gitPush(workingDir);
-  if (result.status === "error") {
-    return { success: false, error: result.message };
-  }
-  return { success: true, message: result.message ?? "Push successful" };
-}
-async function gitSyncAction(workingDir) {
-  const result = await gitSync(workingDir);
-  if (result.status === "error") {
-    return { success: false, error: result.message };
-  }
-  return { success: true, message: result.message ?? "Sync successful" };
-}
-async function executeLocalAction(action, workingDir, options) {
-  if (action === "open-daemon-logs")
-    return openDaemonLogs(workingDir, options);
-  try {
-    await access3(workingDir);
-  } catch {
-    return { success: false, error: `Directory not found: ${workingDir}` };
-  }
-  const handler2 = actionHandlers[action];
-  if (handler2)
-    return handler2(workingDir);
-  return { success: false, error: `Unknown action: ${action}` };
-}
-var DETACHED_SHELL_SPAWN_OPTIONS, actionHandlers;
-var init_execute_local_action = __esm(() => {
-  init_resolve_local_web_port();
-  init_git();
-  DETACHED_SHELL_SPAWN_OPTIONS = {
-    stdio: "ignore",
-    detached: true,
-    shell: true
-  };
-  actionHandlers = {
-    "open-vscode": openVscode,
-    "open-finder": openFinder,
-    "open-cursor": openCursor,
-    "open-github-desktop": openGithubDesktop,
-    "open-daemon-logs": openDaemonLogs,
-    "git-discard-file": gitDiscardFileAction,
-    "git-discard-all": gitDiscardAllAction,
-    "git-pull": gitPullAction,
-    "git-push": gitPushAction,
-    "git-sync": gitSyncAction
-  };
-});
-
-// src/infrastructure/local-actions/index.ts
-var init_local_actions = __esm(() => {
-  init_execute_local_action();
-});
-
-// src/infrastructure/local-actions/pick-folder.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-function runPicker(command, args2) {
-  try {
-    const path3 = execFileSync2(command, args2, { encoding: "utf8", timeout: 300000 }).trim();
-    if (!path3)
-      return { success: false, error: "No folder selected" };
-    return { success: true, path: path3 };
-  } catch (error51) {
-    const exitCode = typeof error51 === "object" && error51 !== null && "status" in error51 ? error51.status : null;
-    if (exitCode === 1)
-      return { success: false, error: "Cancelled", cancelled: true };
-    const message = error51 instanceof Error ? error51.message : String(error51);
-    return { success: false, error: message };
-  }
-}
-function pickFolderDialog() {
-  switch (process.platform) {
-    case "darwin":
-      return runPicker("osascript", [
-        "-e",
-        'POSIX path of (choose folder with prompt "Select workspace folder")'
-      ]);
-    case "win32":
-      return runPicker("powershell", [
-        "-NoProfile",
-        "-Command",
-        [
-          "Add-Type -AssemblyName System.Windows.Forms",
-          "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
-          '$dialog.Description = "Select workspace folder"',
-          "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
-          "  Write-Output $dialog.SelectedPath",
-          "  exit 0",
-          "}",
-          "exit 1"
-        ].join("; ")
-      ]);
-    default:
-      return runPicker("zenity", [
-        "--file-selection",
-        "--directory",
-        "--title=Select workspace folder"
-      ]);
-  }
-}
-var init_pick_folder = () => {};
-
 // src/daemon/domain/usecase/refresh-machine-capabilities.ts
 async function refreshMachineCapabilities(deps) {
   return deps.refresh.refresh();
@@ -111378,15 +111747,15 @@ var init_command_dispatch = __esm(() => {
   init_command_event_types();
   init_command_sync_heartbeat();
   init_daemon_services();
+  init_refresh_models_outcome();
+  init_local_actions();
+  init_pick_folder();
   init_on_request_restart_agent();
   init_on_request_start_agent();
   init_on_request_stop_agent();
   init_on_stop_scope_agent();
   init_ping();
   init_manager();
-  init_refresh_models_outcome();
-  init_local_actions();
-  init_pick_folder();
   init_convex_error();
   GIT_PUSH_ACTIONS = new Set(["git-pull", "git-push", "git-sync", "git-discard-all"]);
   commandEventHandlers = {
@@ -117624,14 +117993,127 @@ var init_command_run_subscription = __esm(() => {
   dispatchedStop = new Set;
 });
 
-// src/daemon/infrastructure/agent-operational/agent-operational-read-model.ts
-function isOperationalCircuitOpen2(row) {
-  return row?.operationalState === "circuit_open";
+// src/daemon/entry/task-inbox-membership-registry.ts
+function registerTaskInboxRoomMembershipRefresh(refresh) {
+  refreshRoomMembership = refresh;
 }
-function isOperationalStopIntentActive2(row) {
-  return row?.stopState === "stopped" || row?.stopState === "stopping" || row?.stopState === "pending";
+function unregisterTaskInboxRoomMembershipRefresh() {
+  refreshRoomMembership = null;
 }
+async function refreshTaskInboxRoomMembership() {
+  await refreshRoomMembership?.();
+}
+var refreshRoomMembership = null;
 
+// src/daemon/infrastructure/agent-operational/operational-signal-feeds.ts
+function chatroomId(value) {
+  return value;
+}
+function signalPage(result) {
+  if (!result || typeof result !== "object")
+    return null;
+  const page = result;
+  if (!page.items?.length || !page.highKey)
+    return null;
+  return {
+    items: page.items,
+    afterSignalKey: "",
+    highSignalKey: page.highKey
+  };
+}
+function createFeed(input) {
+  return input;
+}
+function subscribeArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: chatroomId(input.chatroomId),
+    afterKey: input.afterKey,
+    limit: input.limit
+  };
+}
+function rangeArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: chatroomId(input.chatroomId),
+    afterSignalKey: input.afterSignalKey,
+    throughSignalKey: input.throughSignalKey,
+    limit: input.limit
+  };
+}
+function ackArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: chatroomId(input.chatroomId),
+    throughSignalKey: input.throughSignalKey
+  };
+}
+var createMachineFeed = (config4) => createFeed({
+  kind: config4.kind,
+  subscribe: (client4, input, onResult, onError3) => client4.onUpdate(config4.subscribe, subscribeArgs(input), (result) => {
+    const page = signalPage(result);
+    onResult(page ? { ...page, afterSignalKey: input.afterKey } : result);
+  }, onError3),
+  hydrate: async (client4, input) => await client4.query(config4.hydrate, rangeArgs(input)),
+  acknowledge: async (sessionDeps, input) => await sessionDeps.backend.mutation(config4.acknowledge, ackArgs({
+    ...input,
+    sessionId: sessionDeps.sessionId
+  }))
+}), operationalSignalFeeds;
+var init_operational_signal_feeds = __esm(() => {
+  init_api3();
+  operationalSignalFeeds = {
+    "agent-operational": createMachineFeed({
+      kind: "agent-operational",
+      subscribe: api.machines.subscribeMachineAgentOperationalSignalsSince,
+      hydrate: api.machines.listMachineAgentOperationalStatusForSignalRange,
+      acknowledge: api.machines.ackMachineAgentOperationalSignals
+    }),
+    connectivity: createMachineFeed({
+      kind: "connectivity",
+      subscribe: api.machines.subscribeMachineConnectivitySignalsSince,
+      hydrate: api.machines.listMachineConnectivityStatusForSignalRange,
+      acknowledge: api.machines.ackMachineConnectivitySignals
+    }),
+    "agent-stop": createMachineFeed({
+      kind: "agent-stop",
+      subscribe: api.machines.subscribeMachineAgentStopSignalsSince,
+      hydrate: api.machines.listMachineAgentStopStatusForSignalRange,
+      acknowledge: api.machines.ackMachineAgentStopSignals
+    }),
+    "agent-removal": createMachineFeed({
+      kind: "agent-removal",
+      subscribe: api.machines.subscribeMachineAgentRemovalSignalsSince,
+      hydrate: api.machines.listMachineAgentRemovalStatusForSignalRange,
+      acknowledge: api.machines.ackMachineAgentRemovalSignals
+    })
+  };
+});
+
+// src/daemon/infrastructure/agent-operational/ack-machine-operational-signals.ts
+async function ackMachineSignal(sessionDeps, machineId, chatroomId2, throughSignalKey, kind) {
+  const feed = operationalSignalFeeds[kind];
+  while (true) {
+    const result = await feed.acknowledge(sessionDeps, {
+      machineId,
+      chatroomId: chatroomId2,
+      throughSignalKey
+    });
+    if (!result.hasMore)
+      return;
+    if (result.deletedCount === 0) {
+      throw new Error(`${kind} signal ack reported more work without progress`);
+    }
+  }
+}
+var init_ack_machine_operational_signals = __esm(() => {
+  init_operational_signal_feeds();
+});
+
+// src/daemon/infrastructure/agent-operational/agent-operational-read-model.ts
 class AgentOperationalReadModel {
   rows = new Map;
   replace(rows) {
@@ -117671,211 +118153,21 @@ class AgentOperationalReadModel {
     }
     return changed;
   }
-  get(chatroomId, role) {
-    return this.rows.get(roleKey3(chatroomId, role));
+  get(chatroomId2, role) {
+    return this.rows.get(roleKey3(chatroomId2, role));
   }
 }
-var roleKey3 = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`;
+var roleKey3 = (chatroomId2, role) => `${chatroomId2}:${role.toLowerCase()}`;
 
-// src/daemon/entry/native-delivery/task-delivery-processor.ts
-async function startPendingNativeAgents(tasks, agentMgr, runSerializedForAgent, taskService, operationalModel) {
-  const started = new Set;
-  await Promise.all(tasks.map(async (task) => {
-    if (task.status !== "pending" || !taskService.isNativeHarness(task.agentConfig.agentHarness) || taskService.snapshotRequestsNativeColdSession(task) || !task.agentConfig.workingDir) {
-      return;
-    }
-    const key = `${task.chatroomId}:${task.agentConfig.role.toLowerCase()}`;
-    if (started.has(key))
-      return;
-    const slot = agentMgr.getSlot(task.chatroomId, task.agentConfig.role);
-    if (slot && !isSlotIdle(slot.state))
-      return;
-    const operational = operationalModel?.get(task.chatroomId, task.agentConfig.role);
-    if (isChatroomStopScopeActive(task.chatroomId))
-      return;
-    if (isOperationalCircuitOpen2(operational) || isOperationalStopIntentActive2(operational))
-      return;
-    started.add(key);
-    try {
-      await runSerializedForAgent({ chatroomId: task.chatroomId, role: task.agentConfig.role }, { timeoutMs: 120000 }, (ops, context5) => ops.startAgent({
-        chatroomId: task.chatroomId,
-        role: task.agentConfig.role,
-        agentHarness: task.agentConfig.agentHarness,
-        model: task.agentConfig.model,
-        workingDir: task.agentConfig.workingDir,
-        reason: operational?.operationalState === "running" ? AgentStartReasonEnum["platform.task_monitor_nudge"] : AgentStartReasonEnum["platform.pending_task_wake"],
-        wantResume: false,
-        lifecycleRevision: task.agentConfig.configLifecycleRevision,
-        taskId: task.taskId
-      }, context5.signal));
-    } catch (error51) {
-      console.warn(`[NativeDelivery] pending agent activation failed for ${task.agentConfig.role}@${task.chatroomId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    }
-  }));
-}
-async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSerializedForAgent, taskService, sessionDeps, machineId, pass, lifecycleOutbox, operationalModel, isTaskActive, options) {
-  const filteredTasks = filterSnapshotsExcludingRestartInFlight([...options.snapshots]);
-  if (filteredTasks.length === 0)
-    return;
-  await startPendingNativeAgents(filteredTasks, agentMgr, runSerializedForAgent, taskService, operationalModel);
-  const first = filteredTasks[0];
-  if (pass === "periodic-reconcile") {
-    logNativeDeliveryFallback(pass, first.agentConfig.role, first.chatroomId, first.taskId);
-  } else {
-    logNativeDeliveryTrigger(pass, first.agentConfig.role, first.chatroomId, first.taskId);
-  }
-  await getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
-    tasks: filteredTasks,
-    runtime: runtime4,
-    effectContext: effectContext2,
-    agentMgr,
-    runSerializedForAgent,
-    taskService,
-    sessionDeps,
-    lifecycleOutbox,
-    operationalModel,
-    isTaskActive,
-    machineId,
-    onTaskDelivered: options.onTaskDelivered
+// src/daemon/infrastructure/agent-operational/fetch-machine-agent-operational-status.ts
+async function fetchMachineAgentOperationalStatus(sessionDeps, machineId) {
+  const result = await sessionDeps.backend.query(api.machines.listMachineAgentOperationalStatus, {
+    sessionId: sessionDeps.sessionId,
+    machineId
   });
+  return result;
 }
-var init_task_delivery_processor = __esm(() => {
-  init_agent();
-  init_native_task_delivery_coordinator();
-  init_check_agent_slot();
-  init_service_interfaces();
-  init_restart_orchestrator_in_flight();
-});
-
-// src/daemon/entry/native-delivery/native-delivery-service.ts
-class NativeDeliveryService {
-  deps;
-  unsubscribeAgentTurnEnded;
-  unsubscribeAgentStarted;
-  unsubscribeAgentSessionLost;
-  constructor(deps) {
-    this.deps = deps;
-    this.unsubscribeAgentTurnEnded = deps.agentMgr.subscribeAgentTurnEnded((event) => this.handleAgentTurnEnded(event));
-    this.unsubscribeAgentStarted = deps.agentMgr.subscribeAgentStarted((event) => this.handleAgentStarted(event));
-    this.unsubscribeAgentSessionLost = deps.agentMgr.subscribeAgentSessionLost((event) => this.handleAgentSessionLost(event));
-  }
-  async handleAgentStarted(event) {
-    const tasks = this.deps.taskSnapshotState.listForRole(event.chatroomId, event.role);
-    await this.processSnapshots("operational-status", tasks);
-  }
-  handleAgentSessionLost(event) {
-    getRoleDeliveryState().resetDeliveryState(event.chatroomId, event.role);
-    this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
-  }
-  async handleAgentTurnEnded(event) {
-    this.scheduleRoleDelivery(event.chatroomId, event.role);
-  }
-  scheduleRoleDelivery(chatroomId, role) {
-    setTimeout(() => {
-      const snapshots = this.deps.taskSnapshotState.listForRole(chatroomId, role);
-      this.processSnapshots("operational-status", snapshots).catch((error51) => {
-        console.warn(`[NativeDelivery] post-turn delivery failed for ${role}@${chatroomId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-      });
-    }, 0);
-  }
-  dispose() {
-    this.unsubscribeAgentTurnEnded();
-    this.unsubscribeAgentStarted();
-    this.unsubscribeAgentSessionLost();
-  }
-  get agentTaskState() {
-    return this.deps.agentTaskState;
-  }
-  async handleTaskInboxUpdate(update6) {
-    await this.processSnapshots("inbox-signal", update6.snapshots);
-  }
-  async handleTaskServiceNotification(notification) {
-    if (notification.kind === "bootstrap") {
-      await this.processSnapshots("bootstrap", notification.snapshots);
-      return;
-    }
-    await this.handleTaskInboxUpdate(notification.update);
-  }
-  async processSnapshots(pass, snapshots, onTaskDelivered) {
-    if (snapshots.length === 0)
-      return;
-    await processTasksUpdate(this.deps.runtime, this.deps.effectContext, this.deps.agentMgr, this.deps.runSerializedForAgent, this.deps.taskService, this.deps.sessionDeps, this.deps.machineId, pass, this.deps.lifecycleOutbox, this.deps.agentOperationalReadModel, ({ chatroomId, role, taskId }) => this.deps.agentTaskState.get({ chatroomId, role })?.taskId === taskId, {
-      snapshots,
-      onTaskDelivered: (args2) => {
-        this.recordTaskDelivered(args2);
-        onTaskDelivered?.(args2);
-      }
-    });
-  }
-  recordTaskDelivered(args2) {
-    this.deps.agentTaskState.start(args2);
-  }
-}
-var init_native_delivery_service = __esm(() => {
-  init_task_delivery_processor();
-});
-
-// src/daemon/entry/task-inbox-membership-registry.ts
-function registerTaskInboxRoomMembershipRefresh(refresh) {
-  refreshRoomMembership = refresh;
-}
-function unregisterTaskInboxRoomMembershipRefresh() {
-  refreshRoomMembership = null;
-}
-async function refreshTaskInboxRoomMembership() {
-  await refreshRoomMembership?.();
-}
-var refreshRoomMembership = null;
-
-// src/daemon/infrastructure/agent-operational/operational-signal-contract.ts
-function asChatroomId2(chatroomId) {
-  return chatroomId;
-}
-function buildSubscribeMachineOperationalSignalsSinceArgs(input) {
-  return {
-    sessionId: input.sessionId,
-    machineId: input.machineId,
-    chatroomId: asChatroomId2(input.chatroomId),
-    afterKey: input.afterKey,
-    ...input.limit === undefined ? {} : { limit: input.limit }
-  };
-}
-function buildListOperationalStatusForMachineSignalRangeArgs(input) {
-  return {
-    sessionId: input.sessionId,
-    machineId: input.machineId,
-    chatroomId: asChatroomId2(input.chatroomId),
-    afterSignalKey: input.afterSignalKey,
-    throughSignalKey: input.throughSignalKey,
-    ...input.limit === undefined ? {} : { limit: input.limit }
-  };
-}
-function buildAckMachineOperationalSignalsArgs(input) {
-  return {
-    sessionId: input.sessionId,
-    machineId: input.machineId,
-    chatroomId: asChatroomId2(input.chatroomId),
-    throughSignalKey: input.throughSignalKey
-  };
-}
-
-// src/daemon/infrastructure/agent-operational/ack-machine-operational-signals.ts
-async function ackMachineOperationalSignals(sessionDeps, machineId, chatroomId, throughSignalKey) {
-  while (true) {
-    const result = await sessionDeps.backend.mutation(api.machines.ackMachineOperationalSignals, buildAckMachineOperationalSignalsArgs({
-      sessionId: sessionDeps.sessionId,
-      machineId,
-      chatroomId,
-      throughSignalKey
-    }));
-    if (!result.hasMore)
-      return;
-    if (result.deletedCount === 0) {
-      throw new Error("Operational signal ack reported more work without progress");
-    }
-  }
-}
-var init_ack_machine_operational_signals = __esm(() => {
+var init_fetch_machine_agent_operational_status = __esm(() => {
   init_api3();
 });
 
@@ -117892,6 +118184,9 @@ function throwIfAborted2(signal) {
   if (signal?.aborted)
     throw abortError2();
 }
+function feedFor(options) {
+  return options.feed ?? operationalSignalFeeds["agent-operational"];
+}
 function waitForOperationalSignalPage(options, afterSignalKey) {
   return new Promise((resolve8, reject) => {
     let unsubscribe;
@@ -117918,25 +118213,17 @@ function waitForOperationalSignalPage(options, afterSignalKey) {
       settle2(() => reject(error51));
       return;
     }
-    unsubscribe = options.client.onUpdate(api.machines.subscribeMachineOperationalSignalsSince, buildSubscribeMachineOperationalSignalsSinceArgs({
+    unsubscribe = feedFor(options).subscribe(options.client, {
       sessionId: options.sessionId,
       machineId: options.machineId,
       chatroomId: options.chatroomId,
       afterKey: afterSignalKey,
       limit: options.signalPageLimit ?? DEFAULT_SIGNAL_PAGE_LIMIT2
-    }), (result) => {
-      if (!result || typeof result !== "object")
-        return;
+    }, (result) => {
       const page = result;
-      const items = page.items;
-      const highKey = page.highKey;
-      if (!items?.length || !highKey)
+      if (!page)
         return;
-      settle2(() => resolve8({
-        items,
-        afterSignalKey,
-        highSignalKey: highKey
-      }));
+      settle2(() => resolve8(page));
     }, (error51) => {
       settle2(() => reject(error51));
     });
@@ -117956,14 +118243,14 @@ async function fetchRowsForSignalPage(options, page) {
   let afterSignalKey = page.afterSignalKey;
   while (true) {
     throwIfAborted2(options.signal);
-    const result = await options.client.query(api.machines.listOperationalStatusForMachineSignalRange, buildListOperationalStatusForMachineSignalRangeArgs({
+    const result = await feedFor(options).hydrate(options.client, {
       sessionId: options.sessionId,
       machineId: options.machineId,
       chatroomId: options.chatroomId,
       afterSignalKey,
       throughSignalKey: page.highSignalKey,
       limit: options.operationalPageLimit ?? DEFAULT_OPERATIONAL_PAGE_LIMIT
-    }));
+    });
     rows.push(...result.rows);
     removed.push(...result.removed);
     if (!result.hasMore || !result.nextSignalKey)
@@ -117987,15 +118274,15 @@ async function runOperationalInbox(options, onUpdate) {
 }
 var DEFAULT_SIGNAL_PAGE_LIMIT2 = 100, DEFAULT_OPERATIONAL_PAGE_LIMIT = 500;
 var init_operational_inbox = __esm(() => {
-  init_api3();
+  init_operational_signal_feeds();
 });
 
 // src/daemon/entry/task-inbox-runtime.ts
 function isAbortError2(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
 }
-function roomScopeKey(machineId, chatroomId) {
-  return JSON.stringify([machineId, chatroomId]);
+function roomScopeKey(machineId, chatroomId2) {
+  return JSON.stringify([machineId, chatroomId2]);
 }
 async function runOperationalInboxLoopWithRestart(options, onUpdate, isStopped) {
   let backoffMs = INBOX_RESTART_INITIAL_MS;
@@ -118012,7 +118299,7 @@ async function runOperationalInboxLoopWithRestart(options, onUpdate, isStopped)
     }
   }
 }
-var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
+var 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 commandService = yield* DaemonAgentProcessManagerCommandService;
@@ -118037,31 +118324,25 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
   const serviceStartedAt = Date.now();
   const abort = new AbortController;
   let stopped = false;
-  const taskSnapshotState = session2.taskService.taskSnapshotState;
   const agentOperationalReadModel = new AgentOperationalReadModel;
   const agentTaskState = createAgentTaskStateService();
-  const nativeDelivery = new NativeDeliveryService({
+  const nativeDelivery = session2.taskService.createNativeDeliveryService({
     runtime: runtime4,
     effectContext: effectContext2,
     agentMgr,
     runSerializedForAgent: commandService.runSerializedForAgent,
     sessionDeps,
     machineId: session2.machineId,
-    taskSnapshotState,
     agentTaskState,
     agentOperationalReadModel,
-    lifecycleOutbox,
-    taskService: session2.taskService
+    lifecycleOutbox
   });
-  const unsubscribeTaskService = session2.taskService.subscribe((notification) => nativeDelivery.handleTaskServiceNotification(notification));
   yield* exports_Effect.tryPromise(() => session2.taskService.startTaskInbox(wsClient2)).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[TaskInbox] service bootstrap failed:", error51);
     return exports_Effect.void;
   }));
   const knownRoomIds = new Set;
   const roomWatchers = new Map;
-  let inboxUpdatesInFlight = 0;
-  let reconcileInFlight = false;
   const bootstrapSucceeded = yield* exports_Effect.tryPromise(async () => {
     const rows = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
     agentOperationalReadModel.replace(rows);
@@ -118072,30 +118353,26 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     console.warn("[OperationalInbox] bootstrap failed:", error51);
     return exports_Effect.succeed(false);
   }));
-  const operationalHandler = async (update6) => {
-    const chatroomId = update6.chatroomId;
-    inboxUpdatesInFlight += 1;
+  const operationalHandler = async (kind, update6) => {
+    const chatroomId2 = update6.chatroomId;
+    const changed = agentOperationalReadModel.applySignalPage(update6.rows, update6.removed);
+    await Promise.all(changed.map(({ chatroomId: roomId, role }) => nativeDelivery.requestReconcile({
+      chatroomId: roomId,
+      role,
+      source: "operational-signal"
+    })));
+    inboxStore.save({
+      inboxType: `operational:${kind}`,
+      scopeKey: roomScopeKey(session2.machineId, chatroomId2)
+    }, { afterSignalKey: update6.throughSignalKey });
     try {
-      const changed = agentOperationalReadModel.applySignalPage(update6.rows, update6.removed);
-      const snapshots = changed.flatMap(({ chatroomId: roomId, role }) => taskSnapshotState.listForRole(roomId, role));
-      if (snapshots.length > 0) {
-        await nativeDelivery.processSnapshots("operational-status", snapshots);
-      }
-      inboxStore.save({
-        inboxType: "operational",
-        scopeKey: roomScopeKey(session2.machineId, chatroomId)
-      }, { afterSignalKey: update6.throughSignalKey });
-      try {
-        await ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, update6.throughSignalKey);
-      } catch (error51) {
-        console.warn(`[OperationalInbox room=${chatroomId}] signal cleanup failed:`, error51);
-      }
-    } finally {
-      inboxUpdatesInFlight -= 1;
+      await ackMachineSignal(sessionDeps, session2.machineId, chatroomId2, update6.throughSignalKey, kind);
+    } catch (error51) {
+      console.warn(`[OperationalInbox kind=${kind} room=${chatroomId2}] signal cleanup failed:`, error51);
     }
   };
-  const ensureRoomInboxes = (chatroomId) => {
-    const existing = roomWatchers.get(chatroomId);
+  const ensureRoomInboxes = (chatroomId2) => {
+    const existing = roomWatchers.get(chatroomId2);
     if (existing)
       return existing.startPromise;
     const controller = new AbortController;
@@ -118103,48 +118380,48 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
       controller,
       startPromise: Promise.resolve()
     };
-    roomWatchers.set(chatroomId, entry);
+    roomWatchers.set(chatroomId2, entry);
     entry.startPromise = (async () => {
-      if (!knownRoomIds.has(chatroomId)) {
+      if (!knownRoomIds.has(chatroomId2)) {
         try {
           const current = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
           agentOperationalReadModel.replace(current);
           for (const row of current)
             knownRoomIds.add(row.chatroomId);
         } catch (error51) {
-          console.warn(`[OperationalInbox room=${chatroomId}] operational hydration failed:`, error51);
+          console.warn(`[OperationalInbox room=${chatroomId2}] operational hydration failed:`, error51);
         }
       }
-      const operationalRoomKey = {
-        inboxType: "operational",
-        scopeKey: roomScopeKey(session2.machineId, chatroomId)
-      };
-      const persistedOperationalRoom = inboxStore.get(operationalRoomKey);
-      let operationalCursor;
-      if (persistedOperationalRoom) {
-        operationalCursor = persistedOperationalRoom.state.afterSignalKey;
-        ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, operationalCursor).catch((error51) => console.warn(`[OperationalInbox room=${chatroomId}] startup signal cleanup failed:`, error51));
-      } else if (bootstrapSucceeded) {
-        operationalCursor = operationalSignalCursorAt(serviceStartedAt);
-        try {
-          inboxStore.save(operationalRoomKey, { afterSignalKey: operationalCursor });
-          ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, operationalCursor).catch((error51) => console.warn(`[OperationalInbox room=${chatroomId}] startup signal cleanup failed:`, error51));
-        } catch (error51) {
-          console.warn(`[OperationalInbox room=${chatroomId}] failed to persist bootstrap baseline:`, error51);
+      await Promise.all(["agent-operational", "connectivity", "agent-stop", "agent-removal"].map(async (kind) => {
+        const operationalRoomKey = {
+          inboxType: `operational:${kind}`,
+          scopeKey: roomScopeKey(session2.machineId, chatroomId2)
+        };
+        const persistedRoom = inboxStore.get(operationalRoomKey);
+        let cursor = persistedRoom?.state.afterSignalKey;
+        if (!cursor) {
+          cursor = operationalSignalCursorAt(serviceStartedAt);
+          try {
+            inboxStore.save(operationalRoomKey, { afterSignalKey: cursor });
+          } catch (error51) {
+            console.warn(`[OperationalInbox kind=${kind} room=${chatroomId2}] failed to persist bootstrap baseline:`, error51);
+          }
         }
-      } else {
-        operationalCursor = operationalSignalCursorAt(serviceStartedAt);
-      }
-      runOperationalInboxLoopWithRestart({
-        client: wsClient2,
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        chatroomId,
-        serviceStartedAt,
-        initialAfterSignalKey: operationalCursor,
-        signal: controller.signal
-      }, operationalHandler, () => stopped);
-      await session2.taskService.registerTaskChatroom(chatroomId);
+        if (persistedRoom || bootstrapSucceeded) {
+          ackMachineSignal(sessionDeps, session2.machineId, chatroomId2, cursor, kind).catch((error51) => console.warn(`[OperationalInbox kind=${kind} room=${chatroomId2}] startup signal cleanup failed:`, error51));
+        }
+        runOperationalInboxLoopWithRestart({
+          client: wsClient2,
+          sessionId: session2.sessionId,
+          machineId: session2.machineId,
+          chatroomId: chatroomId2,
+          feed: operationalSignalFeeds[kind],
+          serviceStartedAt,
+          initialAfterSignalKey: cursor,
+          signal: controller.signal
+        }, (update6) => operationalHandler(kind, update6), () => stopped);
+      }));
+      await session2.taskService.registerTaskChatroom(chatroomId2);
     })();
     return entry.startPromise;
   };
@@ -118160,35 +118437,25 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
         ...new Set((workspaces ?? []).map((workspace) => workspace.chatroomId))
       ];
       const activeChatroomIds = new Set(chatroomIds);
-      for (const [chatroomId, watcher] of roomWatchers) {
-        if (activeChatroomIds.has(chatroomId))
+      for (const [chatroomId2, watcher] of roomWatchers) {
+        if (activeChatroomIds.has(chatroomId2))
           continue;
         watcher.controller.abort();
-        session2.taskService.unregisterTaskChatroom(chatroomId);
-        roomWatchers.delete(chatroomId);
-        knownRoomIds.delete(chatroomId);
+        session2.taskService.unregisterTaskChatroom(chatroomId2);
+        roomWatchers.delete(chatroomId2);
+        knownRoomIds.delete(chatroomId2);
       }
-      await Promise.all(chatroomIds.map((chatroomId) => ensureRoomInboxes(chatroomId)));
+      await Promise.all(chatroomIds.map((chatroomId2) => ensureRoomInboxes(chatroomId2)));
     } catch (error51) {
       console.warn("[TaskInbox] room membership refresh failed:", error51);
     }
   };
   registerTaskInboxRoomMembershipRefresh(refreshRoomMembership2);
   yield* exports_Effect.promise(refreshRoomMembership2);
-  yield* exports_Effect.tryPromise(() => Promise.all([...knownRoomIds].map((chatroomId) => ensureRoomInboxes(chatroomId)))).pipe(exports_Effect.catchAll((error51) => {
+  yield* exports_Effect.tryPromise(() => Promise.all([...knownRoomIds].map((chatroomId2) => ensureRoomInboxes(chatroomId2)))).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[OperationalInbox] initial watcher start failed:", error51);
     return exports_Effect.void;
   }));
-  const reconcileTimer = setInterval(() => {
-    if (stopped || inboxUpdatesInFlight > 0 || reconcileInFlight)
-      return;
-    reconcileInFlight = true;
-    nativeDelivery.processSnapshots("periodic-reconcile", taskSnapshotState.listAll()).catch((error51) => {
-      console.warn("[TaskInbox] local delivery reconciliation failed:", error51);
-    }).finally(() => {
-      reconcileInFlight = false;
-    });
-  }, NATIVE_DELIVERY_RECONCILE_MS);
   return {
     nativeDelivery,
     stop() {
@@ -118197,9 +118464,7 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
       for (const watcher of roomWatchers.values()) {
         watcher.controller.abort();
       }
-      clearInterval(reconcileTimer);
       unregisterTaskInboxRoomMembershipRefresh();
-      unsubscribeTaskService();
       session2.taskService.stopTaskInbox();
       nativeDelivery.dispose();
       nativeDelivery.agentTaskState.clearAll();
@@ -118211,10 +118476,10 @@ var init_task_inbox_runtime = __esm(() => {
   init_esm();
   init_daemon_services();
   init_api3();
-  init_native_delivery_service();
   init_ack_machine_operational_signals();
   init_fetch_machine_agent_operational_status();
   init_operational_inbox();
+  init_operational_signal_feeds();
   init_inbox();
   init_service_interfaces();
 });
@@ -118560,11 +118825,11 @@ var init_on_daemon_shutdown = __esm(() => {
       console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s) locally...`);
       let totalStopped = 0;
       let totalFailed = 0;
-      yield* exports_Effect.all(activeAgents.map(({ chatroomId, role }) => exports_Effect.promise(() => agentPm.stopAgent({ chatroomId, role, reason: "daemon.shutdown" })).pipe(exports_Effect.tap(() => exports_Effect.sync(() => {
+      yield* exports_Effect.all(activeAgents.map(({ chatroomId: chatroomId2, role }) => exports_Effect.promise(() => agentPm.stopAgent({ chatroomId: chatroomId2, role, reason: "daemon.shutdown" })).pipe(exports_Effect.tap(() => exports_Effect.sync(() => {
         totalStopped += 1;
       })), exports_Effect.catchAll((e) => exports_Effect.sync(() => {
         totalFailed += 1;
-        console.log(`   ⚠️  Failed to stop ${role}@${chatroomId}: ${e.message}`);
+        console.log(`   ⚠️  Failed to stop ${role}@${chatroomId2}: ${e.message}`);
       })))), { concurrency: "unbounded" });
       if (totalFailed > 0) {
         console.log(`[${formatTimestamp()}] Shutdown stops: ${totalStopped} stopped, ${totalFailed} failed`);
@@ -118746,7 +119011,12 @@ Listening for commands...`);
     registerCommandInboundHandler(async (event) => {
       evictStaleDedupEntries(dedupTracker);
       if (event.type === "command.received") {
-        await handleInboundCommandEvent(event.commandId, dedupTracker, effectContext2, session2, event.claimedCommand, taskInboxHandle.nativeDelivery);
+        const nativeDelivery = taskInboxHandle?.nativeDelivery;
+        if (!nativeDelivery) {
+          console.warn("[Daemon] command received before task inbox started");
+          return;
+        }
+        await handleInboundCommandEvent(event.commandId, dedupTracker, effectContext2, session2, event.claimedCommand, nativeDelivery);
       } else {
         await drainActionableCommandRuns(session2, commandRunRuntime);
       }
@@ -119381,15 +119651,15 @@ function startEnhancerJobSubscriber2(deps, onEvent) {
   const onError3 = (err) => {
     console.warn(`[daemon] enhancer-job subscriber error: ${err instanceof Error ? err.message : String(err)}`);
   };
-  const watchChatroom = (chatroomId) => {
-    if (watchers.has(chatroomId) || stopped)
+  const watchChatroom = (chatroomId2) => {
+    if (watchers.has(chatroomId2) || stopped)
       return;
     const unsub = deps.wsClient.onUpdate(api.daemon.enhancer.index.pendingForChatroom, {
       sessionId: deps.sessionId,
       machineId: deps.machineId,
-      chatroomId
+      chatroomId: chatroomId2
     }, onPendingJobs, onError3);
-    watchers.set(chatroomId, unsub);
+    watchers.set(chatroomId2, unsub);
   };
   const refreshChatrooms = async () => {
     if (refreshInFlight)
@@ -119874,10 +120144,10 @@ function queryEventStream(db, input) {
     payload: JSON.parse(row.payload_json)
   }));
 }
-function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
+function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
     source ? "AND source = ?" : "",
-    chatroomId ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
+    chatroomId2 ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
     role ? "AND json_extract(metadata_json, '$.role') = ?" : "",
     harness ? "AND (json_extract(metadata_json, '$.harness') = ? OR source = ?)" : "",
     fromTimestamp !== undefined ? "AND timestamp >= ?" : "",
@@ -119886,7 +120156,7 @@ function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, ha
   const values3 = [
     afterId,
     ...source ? [source] : [],
-    ...chatroomId ? [chatroomId] : [],
+    ...chatroomId2 ? [chatroomId2] : [],
     ...role ? [role] : [],
     ...harness ? [harness, `harness:${harness}`] : [],
     ...fromTimestamp !== undefined ? [fromTimestamp] : [],
@@ -119896,11 +120166,11 @@ function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, ha
   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) {
+function queryHistory(db, beforeId, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
     beforeId ? "AND id < ?" : "",
     source ? "AND source = ?" : "",
-    chatroomId ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
+    chatroomId2 ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
     role ? "AND json_extract(metadata_json, '$.role') = ?" : "",
     harness ? "AND (json_extract(metadata_json, '$.harness') = ? OR source = ?)" : "",
     fromTimestamp !== undefined ? "AND timestamp >= ?" : "",
@@ -119909,7 +120179,7 @@ function queryHistory(db, beforeId, limit = 100, source, chatroomId, role, harne
   const values3 = [
     ...beforeId ? [beforeId] : [],
     ...source ? [source] : [],
-    ...chatroomId ? [chatroomId] : [],
+    ...chatroomId2 ? [chatroomId2] : [],
     ...role ? [role] : [],
     ...harness ? [harness, `harness:${harness}`] : [],
     ...fromTimestamp !== undefined ? [fromTimestamp] : [],
@@ -119919,9 +120189,9 @@ function queryHistory(db, beforeId, limit = 100, source, chatroomId, role, harne
   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) {
+function listLogDimensions(db, chatroomId2, limit = 100) {
   const clamped = clamp4(limit);
-  const values3 = (sql) => db.prepare(sql).all(chatroomId, clamped).map((r) => r.v);
+  const values3 = (sql) => db.prepare(sql).all(chatroomId2, clamped).map((r) => r.v);
   const roles = values3("SELECT DISTINCT json_extract(metadata_json, '$.role') AS v FROM log_entries WHERE json_extract(metadata_json, '$.chatroomId') = ? AND json_extract(metadata_json, '$.role') IS NOT NULL ORDER BY v LIMIT ?");
   const meta3 = values3("SELECT DISTINCT json_extract(metadata_json, '$.harness') AS v FROM log_entries WHERE json_extract(metadata_json, '$.chatroomId') = ? AND json_extract(metadata_json, '$.harness') IS NOT NULL ORDER BY v LIMIT ?");
   const source = values3("SELECT DISTINCT substr(source, 9) AS v FROM log_entries WHERE json_extract(metadata_json, '$.chatroomId') = ? AND source LIKE 'harness:%' ORDER BY v LIMIT ?");
@@ -120105,17 +120375,17 @@ var init_persistence = __esm(() => {
 // src/daemon/infrastructure/repository/log-repository.ts
 function createLogRepository(db) {
   return {
-    queryAfterId(afterId = 0, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
-      return queryAfterId(db, afterId, limit, source, chatroomId, role, harness, fromTimestamp, toTimestamp);
+    queryAfterId(afterId = 0, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
+      return queryAfterId(db, afterId, limit, source, chatroomId2, role, harness, fromTimestamp, toTimestamp);
     },
-    queryHistory(beforeId, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
-      return queryHistory(db, beforeId, limit, source, chatroomId, role, harness, fromTimestamp, toTimestamp);
+    queryHistory(beforeId, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
+      return queryHistory(db, beforeId, limit, source, chatroomId2, role, harness, fromTimestamp, toTimestamp);
     },
     listSources(limit = 100) {
       return listDistinctSources(db, limit);
     },
-    listDimensions(chatroomId, limit = 100) {
-      return listLogDimensions(db, chatroomId, limit);
+    listDimensions(chatroomId2, limit = 100) {
+      return listLogDimensions(db, chatroomId2, limit);
     },
     writeChatroomEvent(event) {
       return appendChatroomEvent(db, event);
@@ -133927,8 +134197,8 @@ function listLogHistory(reader, input) {
   const entries2 = input.afterId !== undefined ? reader.queryAfterId(input.afterId, limit, input.source, input.chatroomId, input.role, input.harness, input.fromTimestamp, input.toTimestamp) : reader.queryHistory(input.beforeId, limit, input.source, input.chatroomId, input.role, input.harness, input.fromTimestamp, input.toTimestamp);
   return { entries: entries2 };
 }
-function listLogDimensions2(reader, chatroomId, limit = 100) {
-  return reader.listDimensions ? reader.listDimensions(chatroomId, limit) : { roles: [], harnesses: [] };
+function listLogDimensions2(reader, chatroomId2, limit = 100) {
+  return reader.listDimensions ? reader.listDimensions(chatroomId2, limit) : { roles: [], harnesses: [] };
 }
 function listLogSources(reader, limit = 100) {
   return { sources: reader.listSources(limit) };
@@ -135146,7 +135416,7 @@ handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("
     console.error(`error: required option '${flag} <...>' not specified`);
     process.exit(1);
   }
-  const { chatroomId, role, nextRole } = options;
+  const { chatroomId: chatroomId2, role, nextRole } = options;
   await maybeRequireAuth();
   const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
@@ -135165,7 +135435,7 @@ handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("
     process.exit(1);
   }
   const { handoff: handoff2 } = await Promise.resolve().then(() => (init_handoff(), exports_handoff));
-  await handoff2(chatroomId, {
+  await handoff2(chatroomId2, {
     role,
     message,
     nextRole
@@ -135489,18 +135759,18 @@ registerChatroomRoleCommand(program2, {
   name: "get-system-prompt",
   description: "Fetch the system prompt for your role in a chatroom",
   maybeRequireAuth,
-  run: async (chatroomId, { role }) => {
+  run: async (chatroomId2, { role }) => {
     const { getSystemPrompt: getSystemPrompt2 } = await Promise.resolve().then(() => (init_get_system_prompt(), exports_get_system_prompt));
-    await getSystemPrompt2(chatroomId, { role });
+    await getSystemPrompt2(chatroomId2, { role });
   }
 });
 registerChatroomRoleCommand(program2, {
   name: "get-role-guidance",
   description: "Fetch role-specific operating-model guidance for your role in a chatroom",
   maybeRequireAuth,
-  run: async (chatroomId, { role }) => {
+  run: async (chatroomId2, { role }) => {
     const { getRoleGuidance: getRoleGuidance2 } = await Promise.resolve().then(() => (init_get_role_guidance(), exports_get_role_guidance));
-    await getRoleGuidance2(chatroomId, { role });
+    await getRoleGuidance2(chatroomId2, { role });
   }
 });
 var telegramCommand = program2.command("telegram").description("Telegram integration commands");
@@ -135535,9 +135805,9 @@ opencodeCommand.command("install").description("Install chatroom as an OpenCode
 });
 program2.hook("preAction", async (_thisCommand, actionCommand) => {
   const opts = actionCommand.opts();
-  const chatroomId = opts["chatroomId"];
+  const chatroomId2 = opts["chatroomId"];
   const role = opts["role"];
-  if (!chatroomId || !role)
+  if (!chatroomId2 || !role)
     return;
   const { getSessionId: getSessionId2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
   const { getConvexClient: getConvexClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
@@ -135546,8 +135816,8 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
   if (!sessionId)
     return;
   const client4 = await getConvexClient2();
-  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role });
+  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId: chatroomId2, role });
 });
 program2.parse();
 
-//# debugId=1B70D63A805E79F864756E2164756E21
+//# debugId=B512277D42B2480364756E2164756E21