chatroom-cli 1.113.0 → 1.115.1

package/dist/index.js

@@ -30221,17 +30221,7 @@ class AgentProcessManager {
     }
     this.maybeEmitProviderUnavailable(opts.chatroomId, opts.role, slot);
     if (slot.harness && getHarnessCapabilities(slot.harness).supportsNativeIntegration) {
-      for (const handler of this.agentSessionLostHandlers) {
-        try {
-          handler({
-            chatroomId: opts.chatroomId,
-            role: opts.role,
-            harnessSessionId: ctx.harnessSessionId
-          });
-        } catch (error) {
-          console.warn(`[AgentProcessManager] native session-loss cleanup failed for ${opts.role}@${opts.chatroomId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
+      this.notifyAgentSessionLost(opts.chatroomId, opts.role, ctx.harnessSessionId);
     }
     const lifecyclePromise = this.lifecycle.runPromise(exports_Effect.gen(function* () {
       const svc = yield* AgentLifecycleService;
@@ -30522,12 +30512,22 @@ class AgentProcessManager {
   async syncSlotsAfterScopedStop(result) {
     for (const { target } of result.targets) {
       const slot = this.slots.get(agentKey2(target.chatroomId, target.role));
+      this.notifyAgentSessionLost(target.chatroomId, target.role, slot?.pid === target.pid ? slot.harnessSessionId : undefined);
       if (!slot || slot.pid !== target.pid)
         continue;
       this.resetSlotAfterStop(slot);
       await this.clearAgentPidQuietly(target.chatroomId, target.role);
     }
   }
+  notifyAgentSessionLost(chatroomId, role, harnessSessionId) {
+    for (const handler of this.agentSessionLostHandlers) {
+      try {
+        handler({ chatroomId, role, ...harnessSessionId ? { harnessSessionId } : {} });
+      } catch (error) {
+        console.warn(`[AgentProcessManager] native session-loss cleanup failed for ${role}@${chatroomId}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
   queueExitRetry(item) {
     this.exitRetryQueue.push(item);
     if (this.exitRetryTimer === null) {
@@ -31407,17 +31407,6 @@ function isTurnPhaseIdle(phase) {
 }
 var init_check_agent_slot = () => {};
 
-// src/daemon/services/task-service/domain/entities/operational-agent.ts
-function isOperationalDesiredRunning(row) {
-  return row?.operationalState === "running" || row?.operationalState === "starting";
-}
-function isOperationalCircuitOpen(row) {
-  return row?.operationalState === "circuit_open";
-}
-function isOperationalStopIntentActive(row) {
-  return row?.stopState === "stopped" || row?.stopState === "stopping" || row?.stopState === "pending";
-}
-
 // src/daemon/services/task-service/domain/usecase/native-cold-session-delivery.ts
 function snapshotRequestsNativeColdSession(task) {
   return task.requestsNativeColdSession === true;
@@ -31430,18 +31419,12 @@ function isColdStartEligibleSlotState(slot) {
 function isNativeColdSessionDeliveryOwnedSpawn(task, slot) {
   return snapshotRequestsNativeColdSession(task) && isColdStartEligibleSlotState(slot);
 }
-function explainColdSessionDeliveryBlock(task, slot, operational) {
+function explainColdSessionDeliveryBlock(task, slot) {
   if (!snapshotRequestsNativeColdSession(task))
     return null;
   if (isChatroomStopScopeActive(task.chatroomId)) {
     return "chatroom_stop_scope_active";
   }
-  if (isOperationalStopIntentActive(operational)) {
-    return "operational_stop_intent_active";
-  }
-  if (isOperationalCircuitOpen(operational)) {
-    return "operational_circuit_open";
-  }
   if (slot && isSlotSpawning(slot.state)) {
     return `slot_spawning (slotState=${slot.state})`;
   }
@@ -31462,25 +31445,21 @@ function isDeliverableTaskStatus(status3) {
 var init_assigned_task = () => {};
 
 // src/daemon/services/task-service/domain/usecase/native-ready-invariant.ts
-function isAgentReadyForNativeDelivery(task, slot, operational) {
-  return explainAgentReadyForNativeDeliveryBlock(task, slot, operational) === null;
+function isAgentReadyForNativeDelivery(task, slot) {
+  return explainAgentReadyForNativeDeliveryBlock(task, slot) === null;
 }
-function explainAgentReadyForNativeDeliveryBlock(task, slot, explicitOperational) {
+function explainAgentReadyForNativeDeliveryBlock(task, slot) {
   const { agentConfig } = task;
   if (!isNativeHarness(agentConfig.agentHarness)) {
     return `not_native_harness (harness=${agentConfig.agentHarness})`;
   }
-  const operational = explicitOperational;
-  const coldBlock = explainColdSessionDeliveryBlock(task, slot, operational);
+  const coldBlock = explainColdSessionDeliveryBlock(task, slot);
   if (coldBlock) {
     return coldBlock;
   }
   if (isNativeColdSessionDeliveryOwnedSpawn(task, slot)) {
     return null;
   }
-  if (!isOperationalDesiredRunning(operational)) {
-    return `operational_state_not_running (state=${operational?.operationalState ?? "missing"})`;
-  }
   if (!slot) {
     return agentConfig.spawnedAgentPid == null ? "spawned_pid_missing" : `slot_missing (expectedPid=${agentConfig.spawnedAgentPid})`;
   }
@@ -31533,7 +31512,7 @@ function explainNativeDeliveryBlock(task, opts) {
       return `acknowledged_wrong_role (assignedTo=${assignedTo ?? "none"}, role=${role})`;
     }
   }
-  return explainAgentReadyForNativeDeliveryBlock(task, opts.slot, opts.operational);
+  return explainAgentReadyForNativeDeliveryBlock(task, opts.slot);
 }
 function buildNativeInjectionPrompt(params) {
   const preamble = AUGMENTATION_PREAMBLES[params.augmentationMode];
@@ -31820,6 +31799,55 @@ function logNativeDeliveryInjecting(role, chatroomId, taskId) {
   console.log(`[NativeDelivery:inject] ${role}@${chatroomId} task ${taskId} — starting injection`);
 }
 
+// src/daemon/services/task-service/service/native-delivery/role-delivery-state.ts
+function roleKey(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+
+class RoleDeliveryState {
+  generation = new Map;
+  inFlight = new Set;
+  nativeNudgeFailures = new Map;
+  getGeneration(chatroomId, role) {
+    return this.generation.get(roleKey(chatroomId, role)) ?? 0;
+  }
+  resetDeliveryState(chatroomId, role) {
+    const key = roleKey(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 = roleKey(chatroomId, role);
+    if (this.inFlight.has(key))
+      return false;
+    this.inFlight.add(key);
+    return true;
+  }
+  releaseDelivery(chatroomId, role) {
+    this.inFlight.delete(roleKey(chatroomId, role));
+  }
+  recordNativeNudgeFailure(chatroomId, role) {
+    const key = roleKey(chatroomId, role);
+    const count3 = (this.nativeNudgeFailures.get(key) ?? 0) + 1;
+    this.nativeNudgeFailures.set(key, count3);
+    return count3;
+  }
+  clearNativeNudgeFailures(chatroomId, role) {
+    this.nativeNudgeFailures.delete(roleKey(chatroomId, role));
+  }
+  getNativeNudgeFailures(chatroomId, role) {
+    return this.nativeNudgeFailures.get(roleKey(chatroomId, role)) ?? 0;
+  }
+}
+function getRoleDeliveryState() {
+  shared ??= new RoleDeliveryState;
+  return shared;
+}
+var shared;
+
 // 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");
@@ -31831,9 +31859,6 @@ function stableBlockReason(reason) {
     "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",
@@ -31871,8 +31896,7 @@ function decideNextDelivery(tasks, context5) {
     return { kind: "wait", taskId: task.taskId, reason: "agent_start_in_flight" };
   }
   const blockReason = context5.explainNativeDeliveryBlock(task, {
-    slot: context5.slot,
-    operational: context5.operational
+    slot: context5.slot
   });
   if (blockReason === null) {
     return {
@@ -31902,112 +31926,27 @@ var init_delivery_decision = __esm(() => {
   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) {
+function roleKey2(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 function markRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  inFlight.set(roleKey(chatroomId, role), correlationId);
+  inFlight.set(roleKey2(chatroomId, role), correlationId);
 }
 function clearRestartOrchestratorInFlight(chatroomId, role, correlationId) {
-  const key = roleKey(chatroomId, role);
+  const key = roleKey2(chatroomId, role);
   if (correlationId !== undefined && inFlight.get(key) !== correlationId)
     return;
   inFlight.delete(key);
 }
 function isRestartOrchestratorInFlight(chatroomId, role) {
-  return inFlight.has(roleKey(chatroomId, role));
+  return inFlight.has(roleKey2(chatroomId, role));
 }
 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) {
@@ -32017,17 +31956,7 @@ class NativeTaskDeliveryCoordinator {
     const tasks = params.tasks;
     if (tasks.length === 0)
       return;
-    const {
-      runtime: runtime4,
-      effectContext: effectContext2,
-      agentMgr,
-      sessionDeps,
-      operationalModel,
-      isTaskActive,
-      machineId,
-      onTaskDelivered,
-      executors
-    } = params;
+    const { runtime: runtime4, effectContext: effectContext2, agentMgr, isTaskActive, onTaskDelivered, executors } = params;
     const deliveryState = getRoleDeliveryState();
     const taskService = params.taskService;
     const groups = new Map;
@@ -32050,12 +31979,10 @@ class NativeTaskDeliveryCoordinator {
         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),
@@ -32070,8 +31997,7 @@ class NativeTaskDeliveryCoordinator {
         attemptId,
         slotState: slot?.state ?? "missing",
         nativeTurnPhase: slot?.nativeTurnPhase ?? "unknown",
-        harnessSessionPresent: Boolean(slot?.harnessSessionId),
-        operationalState: operational?.operationalState ?? "missing"
+        harnessSessionPresent: Boolean(slot?.harnessSessionId)
       });
       const row = ("taskId" in decision ? sortedTasks.find((candidate) => candidate.taskId === decision.taskId) : firstTask) ?? firstTask;
       if (decision.kind === "idle" || decision.kind === "blocked" || decision.kind === "wait") {
@@ -32089,7 +32015,7 @@ class NativeTaskDeliveryCoordinator {
           continue;
         try {
           if (executors) {
-            const startResult2 = await executors.startAgent(row, operational?.operationalState);
+            const startResult2 = await executors.startAgent(row);
             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;
           }
@@ -32099,7 +32025,7 @@ class NativeTaskDeliveryCoordinator {
             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"],
+            reason: AgentStartReasonEnum["platform.pending_task_wake"],
             wantResume: false,
             lifecycleRevision: row.agentConfig.configLifecycleRevision,
             taskId: row.taskId
@@ -32134,17 +32060,15 @@ class NativeTaskDeliveryCoordinator {
         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
+        const full = yield* exports_Effect.tryPromise(() => taskService.loadAssignedTaskForAction({
+          chatroomId: row.chatroomId,
+          role: row.agentConfig.role,
+          taskId: row.taskId
         }));
-        if (!backend2) {
+        if (!full) {
           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);
@@ -32168,40 +32092,37 @@ 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) {
+async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSerializedForAgent, taskService, sessionDeps, machineId, pass, lifecycleOutbox, 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({
+    startAgent: (task) => 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"],
+      reason: 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
+      const full = await taskService.loadAssignedTaskForAction({
+        chatroomId: task.chatroomId,
+        role: task.agentConfig.role,
+        taskId: task.taskId
       });
-      if (!backend2)
+      if (!full)
         return { kind: "task-unavailable" };
-      const full = mapAssignedTaskView(backend2);
       let delivered;
       await taskService.deliverNativeTask(full, harnessSessionId, (result) => {
         delivered = result;
@@ -32219,7 +32140,6 @@ async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSeriali
     taskService,
     sessionDeps,
     lifecycleOutbox,
-    operationalModel,
     isTaskActive,
     machineId,
     onTaskDelivered: options.onTaskDelivered,
@@ -32229,7 +32149,6 @@ async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSeriali
 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
@@ -32250,6 +32169,7 @@ class NativeDeliveryService {
     this.unsubscribeTaskService = deps.taskService.subscribe?.((notification) => this.handleTaskServiceNotification(notification));
   }
   async handleAgentStarted(event) {
+    this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
     await this.requestReconcile({
       chatroomId: event.chatroomId,
       role: event.role,
@@ -32262,7 +32182,7 @@ class NativeDeliveryService {
     this.requestReconcile({
       chatroomId: event.chatroomId,
       role: event.role,
-      source: "operational-signal"
+      source: "agent-session-lost"
     }).catch((error) => {
       console.warn(`[NativeDelivery:failure] role=${event.role} chatroom=${event.chatroomId} operation=session-loss-reconcile error=${error instanceof Error ? error.message : String(error)}`);
     });
@@ -32276,6 +32196,19 @@ class NativeDeliveryService {
       });
       const errorDetail = completion.error;
       console.error(`[NativeDelivery:turn-failed] chatroom=${event.chatroomId} role=${event.role} task=${activeTask?.taskId ?? "none"} turn=${completion.turnId} status=${completion.status} source=${completion.source} error=${errorDetail ?? "none"}`);
+      if (activeTask) {
+        try {
+          await this.deps.taskService.releaseTaskAfterTurnFailure({
+            chatroomId: event.chatroomId,
+            role: event.role,
+            taskId: activeTask.taskId
+          });
+        } catch (error) {
+          console.error(`[NativeDelivery:turn-failed-recovery-error] chatroom=${event.chatroomId} role=${event.role} task=${activeTask.taskId} turn=${completion.turnId} error=${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+          return { kind: "hold-slot", reason: "task-recovery-failed" };
+        }
+        this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+      }
       const fact = {
         kind: "turn_failed",
         chatroomId: event.chatroomId,
@@ -32297,10 +32230,13 @@ class NativeDeliveryService {
         await this.deps.lifecycleOutbox.enqueue(fact);
       } catch (error) {
         console.error(`[NativeDelivery:turn-failed-outbox-error] chatroom=${event.chatroomId} role=${event.role} turn=${completion.turnId} error=${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        if (activeTask)
+          return { kind: "release-slot" };
         return { kind: "hold-slot", reason: "turn-failed-outbox-enqueue-failed" };
       }
       return { kind: "release-slot" };
     }
+    this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
     this.scheduleRoleDelivery(event.chatroomId, event.role);
     return { kind: "release-slot" };
   }
@@ -32392,6 +32328,19 @@ class NativeDeliveryService {
     this.reconcileStates.set(key, state);
     await state.promise;
   }
+  async reconcileAfterAgentRestart(args2) {
+    const delivered = [];
+    await this.deps.taskService.syncAssignedTaskSnapshots();
+    await this.requestReconcile({
+      chatroomId: args2.chatroomId,
+      role: args2.role,
+      source: "restart-completed",
+      onTaskDelivered: ({ taskId }) => {
+        delivered.push(taskId);
+      }
+    });
+    return delivered;
+  }
   async requestReconcileForSnapshots(snapshots, source) {
     const roles = new Set(snapshots.map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
     await Promise.all([...roles].map((key) => {
@@ -32406,7 +32355,7 @@ class NativeDeliveryService {
   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, {
+    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, ({ chatroomId, role, taskId }) => this.deps.agentTaskState.get({ chatroomId, role })?.taskId === taskId, {
       snapshots,
       onTaskDelivered: (args2) => {
         this.recordTaskDelivered(args2);
@@ -32423,8 +32372,8 @@ var init_native_delivery_service = __esm(() => {
   init_task_delivery_processor();
 });
 
-// src/daemon/services/task-service/service/task-outbox.ts
-class TaskOutbox {
+// src/daemon/services/task-service/service/native-task-delivery-queue.ts
+class NativeTaskDeliveryQueue {
   sender;
   tails = new Map;
   constructor(sender) {
@@ -47172,6 +47121,42 @@ 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, {
@@ -47339,6 +47324,11 @@ var init_inbox = __esm(() => {
 function snapshotKey(taskId, role) {
   return `${taskId}:${role.toLowerCase()}`;
 }
+function isStaleStatusPatch(snapshot, status3, updatedAt) {
+  if (snapshot.updatedAt > updatedAt)
+    return true;
+  return snapshot.updatedAt === updatedAt && snapshot.status === "completed" && status3 !== "completed";
+}
 
 class MachineTaskSnapshotState {
   snapshots = new Map;
@@ -47382,6 +47372,16 @@ class MachineTaskSnapshotState {
       this.snapshots.set(snapshotKey(snapshot.taskId, snapshot.agentConfig.role), snapshot);
     }
   }
+  markStatus(chatroomId, role, taskId, status3, updatedAt) {
+    const key = snapshotKey(taskId, role);
+    const snapshot = this.snapshots.get(key);
+    if (!snapshot || snapshot.chatroomId !== chatroomId)
+      return false;
+    if (isStaleStatusPatch(snapshot, status3, updatedAt))
+      return false;
+    this.snapshots.set(key, { ...snapshot, status: status3, updatedAt });
+    return true;
+  }
 }
 
 // src/daemon/infrastructure/inbox/task-signal-contract.ts
@@ -47521,6 +47521,7 @@ function createConvexNativeTaskDeliveryGateway(backend2) {
     claimPendingTask: async (args2) => {
       await backend2.mutation(api.tasks.claimTask, args2);
     },
+    releaseTaskAfterTurnFailure: (args2) => backend2.mutation(api.tasks.releaseTaskAfterTurnFailure, args2),
     loadDeliveryPrompt: (args2) => backend2.query(api.messages.getTaskDeliveryPrompt, args2),
     recordReceipt: async (args2) => {
       await backend2.mutation(api.taskDeliveryReceipts.record, {
@@ -47536,6 +47537,23 @@ function createConvexNativeTaskDeliveryGateway(backend2) {
     },
     recordSessionAugmentation: async (args2) => {
       await backend2.mutation(api.daemon.agentEvents.sessionAugmented, args2);
+    },
+    loadAssignedTaskForAction: async (args2) => {
+      const row = await backend2.query(api.machines.getAssignedTaskForAction, {
+        sessionId: args2.sessionId,
+        machineId: args2.machineId,
+        taskId: args2.taskId,
+        role: args2.role
+      });
+      if (!row)
+        return null;
+      return mapAssignedTaskView(row);
+    },
+    syncAssignedTaskSnapshots: async ({ sessionId, machineId }) => {
+      await backend2.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
+        sessionId,
+        machineId
+      });
     }
   };
 }
@@ -47566,7 +47584,7 @@ function createTaskService(deps) {
   let inboxClient;
   let serviceStartedAt = 0;
   let stopped = false;
-  const taskOutbox = new TaskOutbox(async (entry) => {
+  const nativeTaskDeliveryQueue = new NativeTaskDeliveryQueue(async (entry) => {
     await exports_Effect.runPromise(runNativeInjectionEffect(entry.task, entry.harnessSessionId, {
       ...deps,
       agentMgr,
@@ -47633,14 +47651,7 @@ function createTaskService(deps) {
       inboxStore = createInboxStateStore(resolveInboxDbPath(deps.machineId));
       serviceStartedAt = Date.now();
       try {
-        await deps.backend.mutation(api.machines.backfillAgentOperationalStatusForMachine, {
-          sessionId: deps.sessionId,
-          machineId: deps.machineId
-        });
-        await deps.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
-          sessionId: deps.sessionId,
-          machineId: deps.machineId
-        });
+        await service4.syncAssignedTaskSnapshots();
         const snapshots = await fetchMachineAssignedTaskSnapshots({ ...deps, convexUrl: deps.convexUrl }, deps.machineId);
         taskSnapshotState.replace(snapshots);
         inboxClient = client2;
@@ -47666,16 +47677,43 @@ function createTaskService(deps) {
       for (const controller of roomControllers.values())
         controller.abort();
       roomControllers.clear();
-      taskOutbox.stop();
+      nativeTaskDeliveryQueue.stop();
       inboxStore?.close();
       inboxStore = undefined;
     },
     listTasksForRole: (chatroomId, role) => taskSnapshotState.listForRole(chatroomId, role),
     listAllTasks: () => taskSnapshotState.listAll(),
     taskSnapshotState,
-    deliverNativeTask: (task, harnessSessionId, onTaskDelivered) => taskOutbox.enqueue({ task, harnessSessionId, onTaskDelivered }),
+    deliverNativeTask: (task, harnessSessionId, onTaskDelivered) => nativeTaskDeliveryQueue.enqueue({ task, harnessSessionId, onTaskDelivered }),
     isNativeHarness,
+    releaseTaskAfterTurnFailure: async (args2) => {
+      const result = await gateway.releaseTaskAfterTurnFailure({
+        sessionId: deps.sessionId,
+        chatroomId: args2.chatroomId,
+        role: args2.role,
+        taskId: args2.taskId
+      });
+      taskSnapshotState.markStatus(args2.chatroomId, args2.role, args2.taskId, result.status, result.updatedAt);
+      return result;
+    },
     snapshotRequestsNativeColdSession,
+    loadAssignedTaskForAction: async ({ chatroomId, role, taskId }) => {
+      const task = await gateway.loadAssignedTaskForAction({
+        sessionId: deps.sessionId,
+        machineId: deps.machineId,
+        taskId,
+        role
+      });
+      return task?.chatroomId === chatroomId ? task : null;
+    },
+    syncAssignedTaskSnapshots: async () => {
+      await gateway.syncAssignedTaskSnapshots({
+        sessionId: deps.sessionId,
+        machineId: deps.machineId
+      });
+      const snapshots = await fetchMachineAssignedTaskSnapshots({ ...deps, convexUrl: deps.convexUrl }, deps.machineId);
+      taskSnapshotState.replace(snapshots);
+    },
     explainNativeDeliveryBlock: (task, options) => explainNativeDeliveryBlock(task, options),
     createNativeDeliveryService: (deliveryDeps) => {
       const nativeDelivery = new NativeDeliveryService({
@@ -47693,7 +47731,6 @@ var init_task_service = __esm(() => {
   init_esm();
   init_native_delivery_service();
   init_native_task_injector();
-  init_api3();
   init_fetch_machine_assigned_task_snapshots();
   init_inbox();
   init_task();
@@ -111168,25 +111205,6 @@ async function forceNativeWaiting(deps, event) {
     action: NATIVE_WAITING_ACTION
   });
 }
-async function syncAssignedTaskSnapshots(deps) {
-  await deps.session.backend.mutation(api.machines.syncMachineAssignedTaskSnapshotsMutation, {
-    sessionId: deps.session.sessionId,
-    machineId: deps.session.machineId
-  });
-}
-async function deliverPendingTasks(deps, event) {
-  const delivered = [];
-  await syncAssignedTaskSnapshots(deps);
-  await deps.nativeDelivery.requestReconcile({
-    chatroomId: event.chatroomId,
-    role: event.role,
-    source: "restart-completed",
-    onTaskDelivered: ({ taskId }) => {
-      delivered.push(taskId);
-    }
-  });
-  return delivered;
-}
 async function runRestartOrchestrator(deps, event) {
   const { chatroomId, role } = event;
   markRestartOrchestratorInFlight(chatroomId, role, event.correlationId);
@@ -111220,7 +111238,10 @@ async function runRestartOrchestrator(deps, event) {
     await forceNativeWaiting(deps, event);
     await emitPhase(deps, event, "ready");
     await emitPhase(deps, event, "deliver");
-    const deliveredTaskIds = await deliverPendingTasks(deps, event);
+    const deliveredTaskIds = await deps.nativeDelivery.reconcileAfterAgentRestart({
+      chatroomId,
+      role
+    });
     await emitPhase(deps, event, "completed");
     await logDaemonAuditEvent(deps.session.logEvent, buildAgentRestartCompletedEvent({
       chatroomId: event.chatroomId,
@@ -118040,313 +118061,20 @@ var init_command_run_subscription = __esm(() => {
   dispatchedStop = new Set;
 });
 
-// src/daemon/entry/task-inbox-membership-registry.ts
-function registerTaskInboxRoomMembershipRefresh(refresh) {
+// src/daemon/entry/workspace-membership-refresh-registry.ts
+function registerWorkspaceMembershipRefresh(refresh) {
   refreshRoomMembership = refresh;
 }
-function unregisterTaskInboxRoomMembershipRefresh() {
+function unregisterWorkspaceMembershipRefresh() {
   refreshRoomMembership = null;
 }
-async function refreshTaskInboxRoomMembership() {
+async function refreshWorkspaceMembership() {
   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) {
-    const changed = [];
-    const nextKeys = new Set;
-    for (const row of rows) {
-      const key = roleKey3(row.chatroomId, row.role);
-      nextKeys.add(key);
-      const prev = this.rows.get(key);
-      if (!prev || prev.revisionKey !== row.revisionKey)
-        changed.push({ chatroomId: row.chatroomId, role: row.role });
-      this.rows.set(key, row);
-    }
-    for (const [key, prev] of this.rows) {
-      if (!nextKeys.has(key)) {
-        changed.push({ chatroomId: prev.chatroomId, role: prev.role });
-        this.rows.delete(key);
-      }
-    }
-    return changed;
-  }
-  applySignalPage(rows, removed) {
-    const changed = [];
-    for (const row of rows) {
-      const key = roleKey3(row.chatroomId, row.role);
-      const prev = this.rows.get(key);
-      if (!prev || prev.revisionKey !== row.revisionKey) {
-        changed.push({ chatroomId: row.chatroomId, role: row.role });
-      }
-      this.rows.set(key, row);
-    }
-    for (const item of removed) {
-      const key = roleKey3(item.chatroomId, item.role);
-      if (this.rows.has(key))
-        changed.push(item);
-      this.rows.delete(key);
-    }
-    return changed;
-  }
-  get(chatroomId2, role) {
-    return this.rows.get(roleKey3(chatroomId2, role));
-  }
-}
-var roleKey3 = (chatroomId2, role) => `${chatroomId2}:${role.toLowerCase()}`;
-
-// 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/infrastructure/agent-operational/operational-inbox.ts
-function operationalSignalCursorAt(timestamp) {
-  return `${String(Math.max(0, Math.floor(timestamp))).padStart(16, "0")}:`;
-}
-function abortError2() {
-  const error51 = new Error("Operational inbox stopped");
-  error51.name = "AbortError";
-  return error51;
-}
-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;
-    let settled = false;
-    const cleanup = () => {
-      unsubscribe?.();
-      unsubscribe = undefined;
-      options.signal?.removeEventListener("abort", onAbort);
-    };
-    const settle2 = (fn2) => {
-      if (settled)
-        return;
-      settled = true;
-      cleanup();
-      fn2();
-    };
-    const onAbort = () => {
-      settle2(() => reject(abortError2()));
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    try {
-      throwIfAborted2(options.signal);
-    } catch (error51) {
-      settle2(() => reject(error51));
-      return;
-    }
-    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) => {
-      const page = result;
-      if (!page)
-        return;
-      settle2(() => resolve8(page));
-    }, (error51) => {
-      settle2(() => reject(error51));
-    });
-  });
-}
-async function* createOperationalSignalIterator(options) {
-  let afterSignalKey = options.initialAfterSignalKey ?? operationalSignalCursorAt(options.serviceStartedAt ?? Date.now());
-  while (!options.signal?.aborted) {
-    const page = await waitForOperationalSignalPage(options, afterSignalKey);
-    yield page;
-    afterSignalKey = page.highSignalKey;
-  }
-}
-async function fetchRowsForSignalPage(options, page) {
-  const rows = [];
-  const removed = [];
-  let afterSignalKey = page.afterSignalKey;
-  while (true) {
-    throwIfAborted2(options.signal);
-    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)
-      break;
-    afterSignalKey = result.nextSignalKey;
-  }
-  return { rows, removed };
-}
-async function runOperationalInbox(options, onUpdate) {
-  for await (const page of createOperationalSignalIterator(options)) {
-    const hydrated = await fetchRowsForSignalPage(options, page);
-    await onUpdate({
-      chatroomId: options.chatroomId,
-      signals: page.items,
-      rows: hydrated.rows,
-      removed: hydrated.removed,
-      afterSignalKey: page.afterSignalKey,
-      throughSignalKey: page.highSignalKey
-    });
-  }
-}
-var DEFAULT_SIGNAL_PAGE_LIMIT2 = 100, DEFAULT_OPERATIONAL_PAGE_LIMIT = 500;
-var init_operational_inbox = __esm(() => {
-  init_operational_signal_feeds();
-});
-
 // src/daemon/entry/task-inbox-runtime.ts
-function isAbortError2(error51) {
-  return error51 instanceof Error && error51.name === "AbortError";
-}
-function roomScopeKey(machineId, chatroomId2) {
-  return JSON.stringify([machineId, chatroomId2]);
-}
-async function runOperationalInboxLoopWithRestart(options, onUpdate, isStopped) {
-  let backoffMs = INBOX_RESTART_INITIAL_MS;
-  while (!isStopped()) {
-    try {
-      await runOperationalInbox(options, onUpdate);
-      return;
-    } catch (error51) {
-      if (isStopped() || isAbortError2(error51))
-        return;
-      console.warn(`[OperationalInbox room=${options.chatroomId}] loop error, restarting in ${backoffMs}ms:`, error51);
-      await new Promise((resolve8) => setTimeout(resolve8, backoffMs));
-      backoffMs = Math.min(backoffMs * 2, INBOX_RESTART_MAX_MS);
-    }
-  }
-}
-var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
+var startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
   const commandService = yield* DaemonAgentProcessManagerCommandService;
@@ -118366,12 +118094,6 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
       query: (fn2, args2) => session2.backend.query(fn2, args2)
     }
   };
-  console.log(`[${formatTimestamp()}] \uD83D\uDCEC Starting task-inbox (chatroom-scoped operational signals)`);
-  const inboxStore = createInboxStateStore(resolveInboxDbPath(session2.machineId));
-  const serviceStartedAt = Date.now();
-  const abort = new AbortController;
-  let stopped = false;
-  const agentOperationalReadModel = new AgentOperationalReadModel;
   const agentTaskState = createAgentTaskStateService();
   const nativeDelivery = session2.taskService.createNativeDeliveryService({
     runtime: runtime4,
@@ -118381,96 +118103,19 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
     sessionDeps,
     machineId: session2.machineId,
     agentTaskState,
-    agentOperationalReadModel,
     lifecycleOutbox
   });
   yield* exports_Effect.tryPromise(() => session2.taskService.startTaskInbox(wsClient2)).pipe(exports_Effect.catchAll((error51) => {
-    console.warn("[TaskInbox] service bootstrap failed:", error51);
+    console.warn("[TaskService] task inbox bootstrap failed:", error51);
     return exports_Effect.void;
   }));
-  const knownRoomIds = new Set;
+  let stopped = false;
   const roomWatchers = new Map;
-  const bootstrapSucceeded = yield* exports_Effect.tryPromise(async () => {
-    const rows = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
-    agentOperationalReadModel.replace(rows);
-    for (const row of rows)
-      knownRoomIds.add(row.chatroomId);
-    return true;
-  }).pipe(exports_Effect.catchAll((error51) => {
-    console.warn("[OperationalInbox] bootstrap failed:", error51);
-    return exports_Effect.succeed(false);
-  }));
-  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 {
-      await ackMachineSignal(sessionDeps, session2.machineId, chatroomId2, update6.throughSignalKey, kind);
-    } catch (error51) {
-      console.warn(`[OperationalInbox kind=${kind} room=${chatroomId2}] signal cleanup failed:`, error51);
-    }
-  };
-  const ensureRoomInboxes = (chatroomId2) => {
-    const existing = roomWatchers.get(chatroomId2);
-    if (existing)
-      return existing.startPromise;
-    const controller = new AbortController;
-    const entry = {
-      controller,
-      startPromise: Promise.resolve()
-    };
-    roomWatchers.set(chatroomId2, entry);
-    entry.startPromise = (async () => {
-      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=${chatroomId2}] operational hydration failed:`, 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);
-          }
-        }
-        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;
+  const ensureRoom = async (chatroomId) => {
+    if (roomWatchers.has(chatroomId))
+      return;
+    roomWatchers.set(chatroomId, new AbortController);
+    await session2.taskService.registerTaskChatroom(chatroomId);
   };
   const refreshRoomMembership2 = async () => {
     try {
@@ -118481,41 +118126,33 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
       if (stopped)
         return;
       const chatroomIds = [
-        ...new Set((workspaces ?? []).map((workspace) => workspace.chatroomId))
+        ...new Set((workspaces ?? []).map((workspace) => String(workspace.chatroomId)))
       ];
       const activeChatroomIds = new Set(chatroomIds);
-      for (const [chatroomId2, watcher] of roomWatchers) {
-        if (activeChatroomIds.has(chatroomId2))
+      for (const [chatroomId, controller] of roomWatchers) {
+        if (activeChatroomIds.has(chatroomId))
           continue;
-        watcher.controller.abort();
-        session2.taskService.unregisterTaskChatroom(chatroomId2);
-        roomWatchers.delete(chatroomId2);
-        knownRoomIds.delete(chatroomId2);
+        controller.abort();
+        session2.taskService.unregisterTaskChatroom(chatroomId);
+        roomWatchers.delete(chatroomId);
       }
-      await Promise.all(chatroomIds.map((chatroomId2) => ensureRoomInboxes(chatroomId2)));
+      await Promise.all(chatroomIds.map((chatroomId) => ensureRoom(chatroomId)));
     } catch (error51) {
-      console.warn("[TaskInbox] room membership refresh failed:", error51);
+      console.warn("[WorkspaceMembership] room membership refresh failed:", error51);
     }
   };
-  registerTaskInboxRoomMembershipRefresh(refreshRoomMembership2);
+  registerWorkspaceMembershipRefresh(refreshRoomMembership2);
   yield* exports_Effect.promise(refreshRoomMembership2);
-  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;
-  }));
   return {
     nativeDelivery,
     stop() {
       stopped = true;
-      abort.abort();
-      for (const watcher of roomWatchers.values()) {
-        watcher.controller.abort();
-      }
-      unregisterTaskInboxRoomMembershipRefresh();
+      for (const controller of roomWatchers.values())
+        controller.abort();
+      unregisterWorkspaceMembershipRefresh();
       session2.taskService.stopTaskInbox();
       nativeDelivery.dispose();
       nativeDelivery.agentTaskState.clearAll();
-      inboxStore.close();
     }
   };
 });
@@ -118523,11 +118160,6 @@ var init_task_inbox_runtime = __esm(() => {
   init_esm();
   init_daemon_services();
   init_api3();
-  init_ack_machine_operational_signals();
-  init_fetch_machine_agent_operational_status();
-  init_operational_inbox();
-  init_operational_signal_feeds();
-  init_inbox();
   init_service_interfaces();
 });
 
@@ -118872,11 +118504,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: chatroomId2, role }) => exports_Effect.promise(() => agentPm.stopAgent({ chatroomId: chatroomId2, role, reason: "daemon.shutdown" })).pipe(exports_Effect.tap(() => exports_Effect.sync(() => {
+      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(() => {
         totalStopped += 1;
       })), exports_Effect.catchAll((e) => exports_Effect.sync(() => {
         totalFailed += 1;
-        console.log(`   ⚠️  Failed to stop ${role}@${chatroomId2}: ${e.message}`);
+        console.log(`   ⚠️  Failed to stop ${role}@${chatroomId}: ${e.message}`);
       })))), { concurrency: "unbounded" });
       if (totalFailed > 0) {
         console.log(`[${formatTimestamp()}] Shutdown stops: ${totalStopped} stopped, ${totalFailed} failed`);
@@ -119698,15 +119330,15 @@ function startEnhancerJobSubscriber2(deps, onEvent) {
   const onError3 = (err) => {
     console.warn(`[daemon] enhancer-job subscriber error: ${err instanceof Error ? err.message : String(err)}`);
   };
-  const watchChatroom = (chatroomId2) => {
-    if (watchers.has(chatroomId2) || stopped)
+  const watchChatroom = (chatroomId) => {
+    if (watchers.has(chatroomId) || stopped)
       return;
     const unsub = deps.wsClient.onUpdate(api.daemon.enhancer.index.pendingForChatroom, {
       sessionId: deps.sessionId,
       machineId: deps.machineId,
-      chatroomId: chatroomId2
+      chatroomId
     }, onPendingJobs, onError3);
-    watchers.set(chatroomId2, unsub);
+    watchers.set(chatroomId, unsub);
   };
   const refreshChatrooms = async () => {
     if (refreshInFlight)
@@ -120026,7 +119658,7 @@ function startAllSubscribers(deps) {
     if (claimed.type === "daemon.workspaceListChanged") {
       enhancerJob.refreshChatrooms();
       gitRequest.refreshWorkspaces();
-      refreshTaskInboxRoomMembership();
+      refreshWorkspaceMembership();
     }
     await dispatchCommandInboundEvent({
       type: "command.received",
@@ -120191,10 +119823,10 @@ function queryEventStream(db, input) {
     payload: JSON.parse(row.payload_json)
   }));
 }
-function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
+function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
     source ? "AND source = ?" : "",
-    chatroomId2 ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
+    chatroomId ? "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 >= ?" : "",
@@ -120203,7 +119835,7 @@ function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId2, role, h
   const values3 = [
     afterId,
     ...source ? [source] : [],
-    ...chatroomId2 ? [chatroomId2] : [],
+    ...chatroomId ? [chatroomId] : [],
     ...role ? [role] : [],
     ...harness ? [harness, `harness:${harness}`] : [],
     ...fromTimestamp !== undefined ? [fromTimestamp] : [],
@@ -120213,11 +119845,11 @@ function queryAfterId(db, afterId = 0, limit = 100, source, chatroomId2, role, h
   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, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
+function queryHistory(db, beforeId, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
   const filters = [
     beforeId ? "AND id < ?" : "",
     source ? "AND source = ?" : "",
-    chatroomId2 ? "AND json_extract(metadata_json, '$.chatroomId') = ?" : "",
+    chatroomId ? "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 >= ?" : "",
@@ -120226,7 +119858,7 @@ function queryHistory(db, beforeId, limit = 100, source, chatroomId2, role, harn
   const values3 = [
     ...beforeId ? [beforeId] : [],
     ...source ? [source] : [],
-    ...chatroomId2 ? [chatroomId2] : [],
+    ...chatroomId ? [chatroomId] : [],
     ...role ? [role] : [],
     ...harness ? [harness, `harness:${harness}`] : [],
     ...fromTimestamp !== undefined ? [fromTimestamp] : [],
@@ -120236,9 +119868,9 @@ function queryHistory(db, beforeId, limit = 100, source, chatroomId2, role, harn
   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, chatroomId2, limit = 100) {
+function listLogDimensions(db, chatroomId, limit = 100) {
   const clamped = clamp4(limit);
-  const values3 = (sql) => db.prepare(sql).all(chatroomId2, clamped).map((r) => r.v);
+  const values3 = (sql) => db.prepare(sql).all(chatroomId, 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 ?");
@@ -120422,17 +120054,17 @@ var init_persistence = __esm(() => {
 // src/daemon/infrastructure/repository/log-repository.ts
 function createLogRepository(db) {
   return {
-    queryAfterId(afterId = 0, limit = 100, source, chatroomId2, role, harness, fromTimestamp, toTimestamp) {
-      return queryAfterId(db, afterId, limit, source, chatroomId2, role, harness, fromTimestamp, toTimestamp);
+    queryAfterId(afterId = 0, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
+      return queryAfterId(db, afterId, 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);
+    queryHistory(beforeId, limit = 100, source, chatroomId, role, harness, fromTimestamp, toTimestamp) {
+      return queryHistory(db, beforeId, limit, source, chatroomId, role, harness, fromTimestamp, toTimestamp);
     },
     listSources(limit = 100) {
       return listDistinctSources(db, limit);
     },
-    listDimensions(chatroomId2, limit = 100) {
-      return listLogDimensions(db, chatroomId2, limit);
+    listDimensions(chatroomId, limit = 100) {
+      return listLogDimensions(db, chatroomId, limit);
     },
     writeChatroomEvent(event) {
       return appendChatroomEvent(db, event);
@@ -134244,8 +133876,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, chatroomId2, limit = 100) {
-  return reader.listDimensions ? reader.listDimensions(chatroomId2, limit) : { roles: [], harnesses: [] };
+function listLogDimensions2(reader, chatroomId, limit = 100) {
+  return reader.listDimensions ? reader.listDimensions(chatroomId, limit) : { roles: [], harnesses: [] };
 }
 function listLogSources(reader, limit = 100) {
   return { sources: reader.listSources(limit) };
@@ -135463,7 +135095,7 @@ handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("
     console.error(`error: required option '${flag} <...>' not specified`);
     process.exit(1);
   }
-  const { chatroomId: chatroomId2, role, nextRole } = options;
+  const { chatroomId, role, nextRole } = options;
   await maybeRequireAuth();
   const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
@@ -135482,7 +135114,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(chatroomId2, {
+  await handoff2(chatroomId, {
     role,
     message,
     nextRole
@@ -135806,18 +135438,18 @@ registerChatroomRoleCommand(program2, {
   name: "get-system-prompt",
   description: "Fetch the system prompt for your role in a chatroom",
   maybeRequireAuth,
-  run: async (chatroomId2, { role }) => {
+  run: async (chatroomId, { role }) => {
     const { getSystemPrompt: getSystemPrompt2 } = await Promise.resolve().then(() => (init_get_system_prompt(), exports_get_system_prompt));
-    await getSystemPrompt2(chatroomId2, { role });
+    await getSystemPrompt2(chatroomId, { role });
   }
 });
 registerChatroomRoleCommand(program2, {
   name: "get-role-guidance",
   description: "Fetch role-specific operating-model guidance for your role in a chatroom",
   maybeRequireAuth,
-  run: async (chatroomId2, { role }) => {
+  run: async (chatroomId, { role }) => {
     const { getRoleGuidance: getRoleGuidance2 } = await Promise.resolve().then(() => (init_get_role_guidance(), exports_get_role_guidance));
-    await getRoleGuidance2(chatroomId2, { role });
+    await getRoleGuidance2(chatroomId, { role });
   }
 });
 var telegramCommand = program2.command("telegram").description("Telegram integration commands");
@@ -135852,9 +135484,9 @@ opencodeCommand.command("install").description("Install chatroom as an OpenCode
 });
 program2.hook("preAction", async (_thisCommand, actionCommand) => {
   const opts = actionCommand.opts();
-  const chatroomId2 = opts["chatroomId"];
+  const chatroomId = opts["chatroomId"];
   const role = opts["role"];
-  if (!chatroomId2 || !role)
+  if (!chatroomId || !role)
     return;
   const { getSessionId: getSessionId2 } = await Promise.resolve().then(() => (init_storage(), exports_storage));
   const { getConvexClient: getConvexClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
@@ -135863,8 +135495,8 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
   if (!sessionId)
     return;
   const client4 = await getConvexClient2();
-  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId: chatroomId2, role });
+  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role });
 });
 program2.parse();
 
-//# debugId=2166B04C5CAC31EC64756E2164756E21
+//# debugId=CAC291D8342AA60364756E2164756E21