chatroom-cli 1.112.0 → 1.115.0

package/dist/index.js

@@ -28823,7 +28823,7 @@ function normalizeAgentLifecycleFact(raw) {
       emittedAt: Number(rest.emittedAt)
     };
   }
-  if (kind === "spawned" || kind === "exited" || kind === "activity") {
+  if (kind === "spawned" || kind === "exited" || kind === "activity" || kind === "turn_failed") {
     return rest;
   }
   throw new Error(`Unknown agent lifecycle fact kind: ${String(kind)}`);
@@ -30154,11 +30154,10 @@ class AgentProcessManager {
       wantResume: slot?.wantResume
     });
     const completionStatus = opts.completion?.status ?? "completed";
-    console.log(`[AgentProcessManager] lifecycle.turn.${completionStatus === "completed" ? "completed" : "terminal"}: role=${opts.role} pid=${opts.pid} harness=${opts.harness} status=${completionStatus}${opts.completion ? ` source=${opts.completion.source}` : ""}`);
+    console.log(`[AgentProcessManager] lifecycle.turn.${completionStatus === "completed" ? "completed" : "failed"}: role=${opts.role} pid=${opts.pid} harness=${opts.harness} status=${completionStatus} completion=${JSON.stringify(opts.completion ?? { status: "completed" })}`);
     if (capabilities.supportsNativeIntegration) {
-      if (completionStatus !== "completed") {
+      if (completionStatus === "process_exited") {
         setNativeTurnPhase(slot, defaultNativeTurnPhase());
-        console.warn(`[AgentProcessManager] Native turn did not complete successfully for ${opts.role}: ${completionStatus}`);
         return;
       }
       this.maybeEmitProviderUnavailable(opts.chatroomId, opts.role, slot);
@@ -30168,11 +30167,25 @@ class AgentProcessManager {
         pid: opts.pid,
         harness: opts.harness,
         slot,
-        eventId: `${opts.pid}:${++this.agentTurnEndedSequence}`
+        eventId: `${opts.pid}:${++this.agentTurnEndedSequence}`,
+        completion: opts.completion ?? {
+          turnId: `${opts.pid}:${this.agentTurnEndedSequence}`,
+          status: "completed",
+          source: "agent-process-manager.agent-end"
+        }
       };
-      await Promise.all([...this.agentTurnEndedHandlers].map((handler) => handler(event)));
+      const dispositions = await Promise.all([...this.agentTurnEndedHandlers].map((handler) => handler(event)));
+      const held = dispositions.find((disposition) => disposition?.kind === "hold-slot");
+      if (held?.kind === "hold-slot") {
+        console.warn(`[AgentProcessManager] Native turn slot held after ${completionStatus}: role=${opts.role} pid=${opts.pid} reason=${held.reason}`);
+        return;
+      }
+      if (completionStatus !== "completed" && !dispositions.some((disposition) => disposition?.kind === "release-slot")) {
+        console.warn(`[AgentProcessManager] Native turn slot held: no task-service disposition returned role=${opts.role} pid=${opts.pid} status=${completionStatus}`);
+        return;
+      }
       setNativeTurnPhase(slot, defaultNativeTurnPhase());
-      console.log(`[AgentProcessManager] ✅ Native agent_end completed for ${opts.role}`);
+      console.log(`[AgentProcessManager] Native agent_end disposition accepted: role=${opts.role} status=${completionStatus} disposition=release-slot`);
       return;
     }
     const result = await handleTurnCompleted({
@@ -30208,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;
@@ -30509,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) {
@@ -31807,6 +31820,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");
@@ -31889,112 +31951,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) {
@@ -32008,10 +31985,8 @@ class NativeTaskDeliveryCoordinator {
       runtime: runtime4,
       effectContext: effectContext2,
       agentMgr,
-      sessionDeps,
       operationalModel,
       isTaskActive,
-      machineId,
       onTaskDelivered,
       executors
     } = params;
@@ -32121,17 +32096,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);
@@ -32155,7 +32128,6 @@ 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();
@@ -32180,15 +32152,13 @@ async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSeriali
       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;
@@ -32216,7 +32186,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
@@ -32237,6 +32206,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,
@@ -32255,7 +32225,57 @@ class NativeDeliveryService {
     });
   }
   async handleAgentTurnEnded(event) {
+    const completion = event.completion;
+    if (completion && completion.status !== "completed") {
+      const activeTask = this.deps.agentTaskState.get({
+        chatroomId: event.chatroomId,
+        role: event.role
+      });
+      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,
+        role: event.role,
+        ...activeTask?.taskId ? { taskId: activeTask.taskId } : {},
+        ...event.slot.harnessSessionId ? { harnessSessionId: event.slot.harnessSessionId } : {},
+        turnId: completion.turnId,
+        status: completion.status,
+        source: completion.source,
+        ...errorDetail ? { error: errorDetail } : {},
+        revisionKey: buildAgentLifecycleRevisionKey("turn_failed", {
+          chatroomId: event.chatroomId,
+          role: event.role,
+          turnId: completion.turnId
+        }),
+        emittedAt: Date.now()
+      };
+      try {
+        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" };
   }
   scheduleRoleDelivery(chatroomId, role) {
     setTimeout(() => {
@@ -32345,6 +32365,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) => {
@@ -32376,8 +32409,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) {
@@ -47125,6 +47158,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, {
@@ -47292,6 +47361,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;
@@ -47335,13 +47409,23 @@ 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
 function asChatroomId(chatroomId) {
   return chatroomId;
 }
-function buildSubscribeTaskStatusSignalsSinceArgs(input) {
+function buildSubscribeTaskDeliverySignalsSinceArgs(input) {
   return {
     sessionId: input.sessionId,
     machineId: input.machineId,
@@ -47350,7 +47434,7 @@ function buildSubscribeTaskStatusSignalsSinceArgs(input) {
     ...input.limit === undefined ? {} : { limit: input.limit }
   };
 }
-function buildListTasksForMachineSignalRangeArgs(input) {
+function buildListTasksForMachineTaskDeliverySignalRangeArgs(input) {
   return {
     sessionId: input.sessionId,
     machineId: input.machineId,
@@ -47400,7 +47484,7 @@ function waitForTaskSignalPage(options, afterSignalKey) {
       settle(() => reject(error51));
       return;
     }
-    unsubscribe = options.client.onUpdate(api.messageList.subscribeTaskStatusSignalsSince, buildSubscribeTaskStatusSignalsSinceArgs({
+    unsubscribe = options.client.onUpdate(api.taskDelivery.subscribeTaskDeliverySignalsSince, buildSubscribeTaskDeliverySignalsSinceArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
       chatroomId: options.chatroomId,
@@ -47437,7 +47521,7 @@ async function fetchSnapshotsForSignalPage(options, page) {
   let afterSignalKey = page.afterSignalKey;
   while (true) {
     throwIfAborted(options.signal);
-    const result = await options.client.query(api.tasks.listTasksForMachineSignalRange, buildListTasksForMachineSignalRangeArgs({
+    const result = await options.client.query(api.taskDelivery.listTasksForMachineTaskDeliverySignalRange, buildListTasksForMachineTaskDeliverySignalRangeArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
       chatroomId: options.chatroomId,
@@ -47474,6 +47558,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, {
@@ -47489,6 +47574,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
+      });
     }
   };
 }
@@ -47519,7 +47621,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,
@@ -47590,10 +47692,7 @@ function createTaskService(deps) {
           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;
@@ -47619,16 +47718,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({
@@ -104587,7 +104713,7 @@ function toConvexLifecycleFact(fact) {
   return {
     ...normalized,
     chatroomId: normalized.chatroomId,
-    ...normalized.kind === "activity" && normalized.taskId ? { taskId: normalized.taskId } : {}
+    ...(normalized.kind === "activity" || normalized.kind === "turn_failed") && normalized.taskId ? { taskId: normalized.taskId } : {}
   };
 }
 function createAgentLifecycleSend(session2) {
@@ -111121,25 +111247,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);
@@ -111173,7 +111280,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,
@@ -117993,14 +118103,14 @@ 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;
@@ -118277,7 +118387,7 @@ var init_operational_inbox = __esm(() => {
   init_operational_signal_feeds();
 });
 
-// src/daemon/entry/task-inbox-runtime.ts
+// src/daemon/entry/operational-inbox-runtime.ts
 function isAbortError2(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
 }
@@ -118299,7 +118409,7 @@ async function runOperationalInboxLoopWithRestart(options, onUpdate, isStopped)
     }
   }
 }
-var 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, startOperationalInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
   const commandService = yield* DaemonAgentProcessManagerCommandService;
@@ -118319,7 +118429,7 @@ 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)`);
+  console.log(`[${formatTimestamp()}] \uD83D\uDCEC Starting operational-inbox (chatroom-scoped operational signals)`);
   const inboxStore = createInboxStateStore(resolveInboxDbPath(session2.machineId));
   const serviceStartedAt = Date.now();
   const abort = new AbortController;
@@ -118338,7 +118448,7 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
     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;
@@ -118447,10 +118557,10 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
       }
       await Promise.all(chatroomIds.map((chatroomId2) => ensureRoomInboxes(chatroomId2)));
     } 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);
@@ -118464,7 +118574,7 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
       for (const watcher of roomWatchers.values()) {
         watcher.controller.abort();
       }
-      unregisterTaskInboxRoomMembershipRefresh();
+      unregisterWorkspaceMembershipRefresh();
       session2.taskService.stopTaskInbox();
       nativeDelivery.dispose();
       nativeDelivery.agentTaskState.clearAll();
@@ -118472,7 +118582,7 @@ var INBOX_RESTART_INITIAL_MS = 1000, INBOX_RESTART_MAX_MS = 30000, startTaskInbo
     }
   };
 });
-var init_task_inbox_runtime = __esm(() => {
+var init_operational_inbox_runtime = __esm(() => {
   init_esm();
   init_daemon_services();
   init_api3();
@@ -118993,7 +119103,7 @@ function createDaemonRuntime(deps) {
           break;
       }
     });
-    taskInboxHandle = yield* startTaskInboxEffect(deps.wsClient);
+    taskInboxHandle = yield* startOperationalInboxEffect(deps.wsClient);
     logObserverSubscriptionHandle = startLogObserverSubscription({ sessionId: session2.sessionId, machineId: session2.machineId }, deps.wsClient);
     const commandRunRuntime = yield* exports_Effect.runtime();
     agenticQueryWorkerHandle = startAgenticQuerySubscriptions({
@@ -119048,7 +119158,7 @@ var init_daemon_runtime = __esm(() => {
   init_command_run_subscription();
   init_log_observer_sync();
   init_init_daemon();
-  init_task_inbox_runtime();
+  init_operational_inbox_runtime();
   init_git_subscription();
   init_api3();
   init_workspace_list_subscription();
@@ -119979,7 +120089,7 @@ function startAllSubscribers(deps) {
     if (claimed.type === "daemon.workspaceListChanged") {
       enhancerJob.refreshChatrooms();
       gitRequest.refreshWorkspaces();
-      refreshTaskInboxRoomMembership();
+      refreshWorkspaceMembership();
     }
     await dispatchCommandInboundEvent({
       type: "command.received",
@@ -135820,4 +135930,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=B512277D42B2480364756E2164756E21
+//# debugId=A4A4E9F28A3DEB2964756E2164756E21