chatroom-cli 1.117.5 → 1.118.0

package/dist/index.js

@@ -26981,6 +26981,16 @@ var init_backend = __esm(() => {
   };
 });
 
+// src/infrastructure/services/cli-gateway.ts
+var CliGatewayService, CliGatewayServiceLive = (gateway) => exports_Layer.succeed(CliGatewayService, {
+  handoff: (args2) => gateway.handoff(args2)
+});
+var init_cli_gateway = __esm(() => {
+  init_esm();
+  CliGatewayService = class CliGatewayService extends exports_Context.Tag("CliGatewayService")() {
+  };
+});
+
 // src/infrastructure/services/session.ts
 var SessionService, SessionServiceLive = (ops) => exports_Layer.succeed(SessionService, {
   getSessionId: () => exports_Effect.promise(() => ops.getSessionId()),
@@ -26995,7 +27005,12 @@ var init_session = __esm(() => {
 
 // src/infrastructure/services/command-effect-helpers.ts
 function commandServicesLayerFromDeps(deps) {
-  return exports_Layer.mergeAll(BackendServiceLive({
+  const gateway = deps.gateway ?? {
+    handoff: async () => {
+      throw new Error("CLI gateway is unavailable");
+    }
+  };
+  return exports_Layer.mergeAll(CliGatewayServiceLive(gateway), BackendServiceLive({
     query: deps.backend.query,
     mutation: deps.backend.mutation,
     ...deps.backend.action ? { action: deps.backend.action } : {}
@@ -27017,6 +27032,17 @@ function requireSessionIdEffect(fail11) {
     return sessionId;
   });
 }
+function requireSessionForChatroomEffect(params) {
+  return exports_Effect.gen(function* () {
+    const sessionId = yield* requireSessionIdEffect(({ convexUrl, otherUrls }) => ({
+      _tag: "NotAuthenticated",
+      convexUrl,
+      otherUrls
+    }));
+    yield* validateChatroomIdEffect(params.chatroomId, (id3) => ({ _tag: "InvalidChatroomId", id: id3 }));
+    return sessionId;
+  });
+}
 function validateChatroomIdEffect(chatroomId, fail11) {
   const valid = typeof chatroomId === "string" && chatroomId.length >= 20 && chatroomId.length <= 40;
   return valid ? exports_Effect.void : exports_Effect.fail(fail11(chatroomId));
@@ -27024,6 +27050,7 @@ function validateChatroomIdEffect(chatroomId, fail11) {
 var init_command_effect_helpers = __esm(() => {
   init_esm();
   init_backend();
+  init_cli_gateway();
   init_session();
 });
 
@@ -27081,6 +27108,7 @@ var init_process = __esm(() => {
 // src/infrastructure/services/index.ts
 var init_services = __esm(() => {
   init_backend();
+  init_cli_gateway();
   init_command_effect_helpers();
   init_clock2();
   init_fs();
@@ -28334,7 +28362,8 @@ function createAgentProcessManagerService(deps) {
     resumeTurnForSlot: (input) => deps.execution.resumeTurnForSlot(input),
     subscribeAgentTurnEnded: (handler) => deps.execution.subscribeAgentTurnEnded(handler),
     subscribeAgentStarted: (handler) => deps.execution.subscribeAgentStarted(handler),
-    subscribeAgentSessionLost: (handler) => deps.execution.subscribeAgentSessionLost(handler)
+    subscribeAgentSessionLost: (handler) => deps.execution.subscribeAgentSessionLost(handler),
+    subscribeAgentTurnProgress: (handler) => deps.execution.subscribeAgentTurnProgress(handler)
   };
 }
 var NATIVE_DELIVERY_SLOT_WAIT_MS = 120000, SLOT_CHANGE_POLL_MS = 100;
@@ -44651,29 +44680,24 @@ async function emitNativeWaitingAfterSpawn(ctx, harness, opts) {
     return false;
   }
 }
-function fireTokenActivity(backend2, sessionId, chatroomId, role, now, lastReportedTokenAt, throttleMs) {
+function fireTokenActivity(onTurnProgress, chatroomId, role, now, lastReportedTokenAt, throttleMs) {
   const t = now();
   if (lastReportedTokenAt.value === 0 || t - lastReportedTokenAt.value >= throttleMs) {
     lastReportedTokenAt.value = t;
-    backend2.mutation(api.participants.recordHarnessActivity, {
-      sessionId,
-      chatroomId,
-      role
-    }).catch(() => {});
+    onTurnProgress({ chatroomId, role });
   }
 }
 function wireTokenActivityReporting(opts) {
   if (!isTeamAgentRole(opts.role))
     return;
+  const onTurnProgress = opts.onTurnProgress;
+  if (!onTurnProgress)
+    return;
   if (opts.activityEmitter) {
     opts.activityEmitter.onActivity((signal) => {
       if (signal.kind !== "progress" || !signal.isFirstForTurn)
         return;
-      opts.backend.mutation(api.participants.recordHarnessActivity, {
-        sessionId: opts.sessionId,
-        chatroomId: opts.chatroomId,
-        role: opts.role
-      }).catch(() => {});
+      onTurnProgress({ chatroomId: opts.chatroomId, role: opts.role });
     });
     return;
   }
@@ -44684,13 +44708,12 @@ function wireTokenActivityReporting(opts) {
   if (!register)
     return;
   register(() => {
-    fireTokenActivity(opts.backend, opts.sessionId, opts.chatroomId, opts.role, now, lastReportedTokenAt, throttleMs);
+    fireTokenActivity(onTurnProgress, opts.chatroomId, opts.role, now, lastReportedTokenAt, throttleMs);
   });
 }
 var NATIVE_TOKEN_ACTIVITY_THROTTLE_MS = 30000;
 var init_native_spawn_presence = __esm(() => {
   init_types();
-  init_api3();
   init_agent_lifecycle_fact();
   init_execution_kind();
 });
@@ -44713,6 +44736,7 @@ class AgentProcessManager {
   exitRetryQueue = [];
   exitRetryTimer = null;
   agentTurnEndedHandlers = new Set;
+  agentTurnProgressHandlers = new Set;
   agentTurnEndedSequence = 0;
   agentStartedHandlers = new Set;
   agentSessionLostHandlers = new Set;
@@ -44800,6 +44824,19 @@ class AgentProcessManager {
     this.agentSessionLostHandlers.add(handler);
     return () => this.agentSessionLostHandlers.delete(handler);
   }
+  subscribeAgentTurnProgress(handler) {
+    this.agentTurnProgressHandlers.add(handler);
+    return () => this.agentTurnProgressHandlers.delete(handler);
+  }
+  emitAgentTurnProgress(event) {
+    for (const handler of this.agentTurnProgressHandlers) {
+      try {
+        handler(event);
+      } catch (error51) {
+        console.warn(`[AgentProcessManager] turn-progress handler failed for ${event.role}@${event.chatroomId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }
+  }
   clearSlotRuntimeState(slot) {
     slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pid = undefined;
@@ -45719,13 +45756,12 @@ class AgentProcessManager {
       });
     }
     wireTokenActivityReporting({
-      backend: this.deps.backend,
-      sessionId: this.deps.sessionId,
       chatroomId: opts.chatroomId,
       role: opts.role,
       spawnResult,
       now: () => this.deps.clock.now(),
-      activityEmitter: spawnResult.activityEmitter
+      activityEmitter: spawnResult.activityEmitter,
+      onTurnProgress: (event) => this.emitAgentTurnProgress(event)
     });
   }
   async finalizeRunningSlot(key, slot, opts, spawnResult, wantResume) {
@@ -45742,7 +45778,7 @@ class AgentProcessManager {
     await this.emitNativeWaiting(opts.chatroomId, opts.role, opts.agentHarness);
     if (getHarnessCapabilities(opts.agentHarness).supportsNativeIntegration) {
       for (const handler of this.agentStartedHandlers) {
-        handler({ chatroomId: opts.chatroomId, role: opts.role }).catch((error51) => {
+        handler({ chatroomId: opts.chatroomId, role: opts.role, reason: opts.reason }).catch((error51) => {
           console.warn(`[AgentProcessManager] native delivery after start failed for ${opts.role}@${opts.chatroomId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
         });
       }
@@ -46941,6 +46977,8 @@ function createConvexNativeTaskDeliveryGateway(backend2) {
         deliveryKind: "native_inject"
       });
     },
+    readTask: async (args2) => await backend2.mutation(api.tasks.readTask, args2),
+    markReceiptStarted: async (args2) => await backend2.mutation(api.taskDeliveryReceipts.markStarted, args2),
     joinWaitingParticipant: async (args2) => {
       await backend2.mutation(api.participants.join, {
         ...args2,
@@ -46987,6 +47025,7 @@ var init_convex_native_task_delivery_gateway = __esm(() => {
 // src/daemon/services/task-service/service/task-service.ts
 function createTaskService(deps) {
   const gateway = createConvexNativeTaskDeliveryGateway(deps.backend);
+  const handoffRepository = deps.handoffRepository;
   const taskInboxState = new TaskInboxState;
   const listeners = new Set;
   let stopInboxWatch;
@@ -46996,6 +47035,120 @@ function createTaskService(deps) {
   const scheduledEventIds = new Set;
   const deliveredEventIds = new Set;
   const taskChains = new Map;
+  const maxBootstrapSweepFailures = 3;
+  let bootstrapSweepPending = true;
+  let bootstrapSweepFailures = 0;
+  let bootstrapSweepInFlight = false;
+  let bootstrapSweepPromise;
+  const REDIVERY_ATTEMPT_CAP = 3;
+  const turnEndAttemptCounts = new Map;
+  const redeliveryExhaustedKeys = new Set;
+  const redeliveryKey = (chatroomId, role, taskId) => `${chatroomId}:${role.toLowerCase()}:${taskId}`;
+  const recordUncoveredTurnEnd = async (args2) => {
+    const key = redeliveryKey(args2.chatroomId, args2.role, args2.taskId);
+    if (redeliveryExhaustedKeys.has(key))
+      return { exceeded: true };
+    const attempts = (turnEndAttemptCounts.get(key) ?? 0) + 1;
+    turnEndAttemptCounts.set(key, attempts);
+    if (attempts < REDIVERY_ATTEMPT_CAP)
+      return { exceeded: false };
+    redeliveryExhaustedKeys.add(key);
+    try {
+      await gateway.recordDeliveryFailure({
+        sessionId: deps.sessionId,
+        machineId: deps.machineId,
+        taskId: args2.taskId,
+        reason: "redelivery_exhausted"
+      });
+    } catch (error51) {
+      console.warn(`[TaskService] redelivery-exhausted failure record failed chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+    console.log(`[NativeDelivery:redelivery-exhausted] chatroom=${args2.chatroomId} role=${args2.role} task=${args2.taskId} attempts=${attempts} — release/redelivery stopped; agent restart (user.start) resets`);
+    return { exceeded: true };
+  };
+  const isRedeliveryExhausted = (args2) => redeliveryExhaustedKeys.has(redeliveryKey(args2.chatroomId, args2.role, args2.taskId));
+  const clearRedeliveryTrackingForTask = (chatroomId, role, taskId) => {
+    const key = redeliveryKey(chatroomId, role, taskId);
+    turnEndAttemptCounts.delete(key);
+    redeliveryExhaustedKeys.delete(key);
+  };
+  const sweepUncoveredInProgressTasks = async () => {
+    let released = 0;
+    let failures3 = 0;
+    for (const task of taskInboxState.listAll()) {
+      if (task.status !== "in_progress")
+        continue;
+      try {
+        const handoff = await handoffRepository.getLatest(task.chatroomId, task.agentConfig.role);
+        if (handoff?.taskIds.includes(task.taskId))
+          continue;
+        const result = await gateway.releaseTaskAfterTurnFailure({
+          sessionId: deps.sessionId,
+          chatroomId: task.chatroomId,
+          role: task.agentConfig.role,
+          taskId: task.taskId
+        });
+        taskInboxState.markStatus(task.chatroomId, task.agentConfig.role, task.taskId, result.status, result.updatedAt);
+        released += 1;
+      } catch (error51) {
+        failures3 += 1;
+        console.warn(`[TaskService] bootstrap task release failed chatroom=${task.chatroomId} task=${task.taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }
+    if (failures3 > 0)
+      throw new Error(`${failures3} bootstrap task release(s) failed`);
+    return released;
+  };
+  const releaseTask = async (args2) => {
+    const result = await gateway.releaseTaskAfterTurnFailure({
+      sessionId: deps.sessionId,
+      chatroomId: args2.chatroomId,
+      role: args2.role,
+      taskId: args2.taskId
+    });
+    taskInboxState.markStatus(args2.chatroomId, args2.role, args2.taskId, result.status, result.updatedAt);
+    const currentTask = taskInboxState.getForRole(args2.chatroomId, args2.role, args2.taskId);
+    if (currentTask?.status === "pending") {
+      pendingTaskReconciliationWatcher.watch(currentTask);
+    } else {
+      pendingTaskReconciliationWatcher.clear(args2.chatroomId, args2.role, args2.taskId);
+    }
+    return result;
+  };
+  const clearRoleRedeliveryTracking = (chatroomId, role) => {
+    const prefix = `${chatroomId}:${role.toLowerCase()}:`;
+    for (const key of [...turnEndAttemptCounts.keys()]) {
+      if (key.startsWith(prefix))
+        turnEndAttemptCounts.delete(key);
+    }
+    for (const key of [...redeliveryExhaustedKeys]) {
+      if (key.startsWith(prefix))
+        redeliveryExhaustedKeys.delete(key);
+    }
+  };
+  const runBootstrapSweep = () => {
+    if (!bootstrapSweepPending)
+      return Promise.resolve();
+    if (bootstrapSweepInFlight)
+      return bootstrapSweepPromise ?? Promise.resolve();
+    bootstrapSweepInFlight = true;
+    bootstrapSweepPromise = sweepUncoveredInProgressTasks().then(() => {
+      bootstrapSweepPending = false;
+      bootstrapSweepFailures = 0;
+    }).catch((error51) => {
+      bootstrapSweepFailures += 1;
+      if (bootstrapSweepFailures >= maxBootstrapSweepFailures) {
+        bootstrapSweepPending = false;
+        console.warn("[TaskService] bootstrap sweep giving up after 3 failed attempts");
+      } else {
+        console.warn(`[TaskService] bootstrap sweep failed (attempt ${bootstrapSweepFailures}/3): ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }).finally(() => {
+      bootstrapSweepInFlight = false;
+      bootstrapSweepPromise = undefined;
+    });
+    return bootstrapSweepPromise;
+  };
   const notifyForDelivery = async (notification) => {
     const results = await Promise.all([...listeners].map((listener) => Promise.resolve(listener(notification))));
     return {
@@ -47009,8 +47162,12 @@ function createTaskService(deps) {
   const applyInboxEvent = (event) => {
     if (event.eventType === "task_deleted" /* TaskDeleted */ || event.task.status === "completed") {
       taskInboxState.remove(event.chatroomId, event.role, event.taskId, event.task.updatedAt);
+      clearRedeliveryTrackingForTask(event.chatroomId, event.role, event.taskId);
       return "handled";
     }
+    if (event.eventType === "task_assigned" /* TaskAssigned */) {
+      clearRedeliveryTrackingForTask(event.chatroomId, event.role, event.taskId);
+    }
     return taskInboxState.upsert([
       {
         taskId: event.task.taskId,
@@ -47119,6 +47276,7 @@ function createTaskService(deps) {
   });
   const reconcileTaskStatuses = (tasks) => {
     taskInboxState.reconcileStatuses(tasks);
+    runBootstrapSweep();
     for (const task of tasks) {
       if (task.status === "pending" || task.status === "acknowledged") {
         pendingTaskReconciliationWatcher.watch(task);
@@ -47158,7 +47316,9 @@ function createTaskService(deps) {
           machineId: deps.machineId
         });
         reconcileTaskStatuses(statusTasks);
+        await runBootstrapSweep();
       } catch (error51) {
+        bootstrapSweepPending = true;
         console.warn("[TaskService] task-status bootstrap failed:", error51);
       }
       if (wsClient2 && !stopInboxWatch) {
@@ -47193,26 +47353,47 @@ function createTaskService(deps) {
       acknowledgementRetryWatcher.stop();
       pendingTaskReconciliationWatcher.stop();
       taskChains.clear();
+      handoffRepository.close();
     },
     listTasksForRole: (chatroomId, role) => taskInboxState.listForRole(chatroomId, role),
     listAllTasks: () => taskInboxState.listAll(),
     debugState: (chatroomId) => buildTaskServiceDebugState({ taskInboxState, chatroomId }),
     taskInboxState,
-    releaseTaskAfterTurnFailure: async (args2) => {
-      const result = await gateway.releaseTaskAfterTurnFailure({
-        sessionId: deps.sessionId,
-        chatroomId: args2.chatroomId,
-        role: args2.role,
-        taskId: args2.taskId
-      });
-      taskInboxState.markStatus(args2.chatroomId, args2.role, args2.taskId, result.status, result.updatedAt);
-      const currentTask = taskInboxState.getForRole(args2.chatroomId, args2.role, args2.taskId);
-      if (currentTask?.status === "pending") {
-        pendingTaskReconciliationWatcher.watch(currentTask);
-      } else {
-        pendingTaskReconciliationWatcher.clear(args2.chatroomId, args2.role, args2.taskId);
+    recordHandoffOutcome: async ({
+      chatroomId,
+      role,
+      targetRole,
+      nextTask,
+      taskIds: providedTaskIds
+    }) => {
+      const taskIds = providedTaskIds ?? taskInboxState.listForRole(chatroomId, role).filter((task) => task.status === "acknowledged" || task.status === "in_progress").map((task) => task.taskId);
+      await handoffRepository.record({
+        chatroomId,
+        role,
+        taskIds,
+        ...nextTask?.taskId ? { nextTaskId: nextTask.taskId } : {},
+        targetRole,
+        handedOffAt: Date.now()
+      });
+      const now = Date.now();
+      for (const taskId of taskIds)
+        taskInboxState.remove(chatroomId, role, taskId, now);
+      if (nextTask)
+        taskInboxState.upsert([nextTask]);
+    },
+    getLatestHandoff: (chatroomId, role) => handoffRepository.getLatest(chatroomId, role),
+    sweepUncoveredInProgressTasks,
+    releaseTaskAfterTurnFailure: (args2) => releaseTask(args2),
+    handleAgentRestart: async ({ chatroomId, role }) => {
+      clearRoleRedeliveryTracking(chatroomId, role);
+      const inFlightTasks = taskInboxState.listForRole(chatroomId, role).filter((task) => task.status === "acknowledged" || task.status === "in_progress");
+      for (const task of inFlightTasks) {
+        try {
+          await releaseTask({ chatroomId, role, taskId: task.taskId });
+        } catch (error51) {
+          console.warn(`[TaskService] agent-restart release failed chatroom=${chatroomId} role=${role} task=${task.taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+        }
       }
-      return result;
     },
     loadAssignedTaskForAction: async ({ chatroomId, role, taskId }) => {
       const task = await gateway.loadAssignedTaskForAction({
@@ -47223,6 +47404,27 @@ function createTaskService(deps) {
       });
       return task?.chatroomId === chatroomId ? task : null;
     },
+    handleAgentTurnProgress: async ({ chatroomId, role, taskId }) => {
+      const task = taskInboxState.getForRole(chatroomId, role, taskId);
+      if (!task)
+        return;
+      if (task.status !== "acknowledged" && task.status !== "in_progress")
+        return;
+      if (task.status === "acknowledged") {
+        try {
+          await gateway.readTask({ sessionId: deps.sessionId, chatroomId, role, taskId });
+          taskInboxState.markStatus(chatroomId, role, taskId, "in_progress", Date.now());
+        } catch (error51) {
+          console.warn(`[TaskService] turn-progress read failed chatroom=${chatroomId} role=${role} task=${taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+          return;
+        }
+      }
+      try {
+        await gateway.markReceiptStarted({ sessionId: deps.sessionId, chatroomId, role, taskId });
+      } catch (error51) {
+        console.warn(`[TaskService] turn-progress receipt mark failed chatroom=${chatroomId} role=${role} task=${taskId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    },
     recordDeliveryFailure: ({ taskId, reason }) => gateway.recordDeliveryFailure({
       sessionId: deps.sessionId,
       machineId: deps.machineId,
@@ -47234,7 +47436,12 @@ function createTaskService(deps) {
       machineId: deps.machineId,
       taskId,
       ...expectedReason ? { expectedReason } : {}
-    })
+    }),
+    recordUncoveredTurnEnd,
+    isRedeliveryExhausted,
+    clearRedeliveryTracking: ({ chatroomId, role }) => {
+      clearRoleRedeliveryTracking(chatroomId, role);
+    }
   };
   return service4;
 }
@@ -47247,6 +47454,63 @@ var init_task_service = __esm(() => {
   init_convex_native_task_delivery_gateway();
 });
 
+// src/daemon/services/task-service/infrastructure/repository/task-handoff-repository.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function normalizeRole(role) {
+  return role.toLowerCase();
+}
+function mapRow(row) {
+  const taskIds = JSON.parse(row.task_ids_json);
+  if (!Array.isArray(taskIds) || !taskIds.every((taskId) => typeof taskId === "string")) {
+    throw new Error("Invalid task handoff task_ids_json");
+  }
+  return {
+    chatroomId: row.chatroom_id,
+    role: row.role,
+    taskIds,
+    ...row.next_task_id ? { nextTaskId: row.next_task_id } : {},
+    targetRole: row.target_role,
+    handedOffAt: row.handed_off_at
+  };
+}
+function createTaskHandoffRepository(dbPath) {
+  mkdirSync2(dirname2(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS task_handoffs (
+      chatroom_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      task_ids_json TEXT NOT NULL,
+      next_task_id TEXT,
+      target_role TEXT NOT NULL,
+      handed_off_at INTEGER NOT NULL,
+      PRIMARY KEY (chatroom_id, role)
+    )
+  `);
+  return {
+    async record(record2) {
+      db.prepare(`INSERT INTO task_handoffs
+           (chatroom_id, role, task_ids_json, next_task_id, target_role, handed_off_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(chatroom_id, role) DO UPDATE SET
+           task_ids_json = excluded.task_ids_json,
+           next_task_id = excluded.next_task_id,
+           target_role = excluded.target_role,
+           handed_off_at = excluded.handed_off_at`).run(record2.chatroomId, normalizeRole(record2.role), JSON.stringify(record2.taskIds), record2.nextTaskId ?? null, record2.targetRole, record2.handedOffAt);
+    },
+    async getLatest(chatroomId, role) {
+      const row = db.prepare("SELECT chatroom_id, role, task_ids_json, next_task_id, target_role, handed_off_at FROM task_handoffs WHERE chatroom_id = ? AND role = ?").get(chatroomId, normalizeRole(role));
+      return row ? mapRow(row) : null;
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+var init_task_handoff_repository = () => {};
+
 // src/daemon/services/task-service/infrastructure/adapters/daemon-audit-port.ts
 function createDaemonAuditPort(logEvent) {
   return { emit: (event) => logDaemonAuditEvent(logEvent, event) };
@@ -47279,6 +47543,9 @@ function decideNextDelivery(tasks, context5) {
   if (!context5.isNativeHarness(context5.agentConfig.agentHarness)) {
     return { kind: "failed", taskId: task.taskId, reason: "unsupported_harness" };
   }
+  if (context5.isRedeliveryExhausted(task.taskId)) {
+    return { kind: "deduplicated", reason: "redelivery_exhausted", taskId: task.taskId };
+  }
   const blockReason = context5.explainNativeDeliveryBlock(task);
   if (blockReason === "acknowledged_wrong_role") {
     return { kind: "failed", taskId: task.taskId, reason: "assigned_elsewhere" };
@@ -47394,7 +47661,8 @@ class NativeTaskDeliveryCoordinator {
         agentConfig,
         configState,
         isNativeHarness: taskService.isNativeHarness,
-        explainNativeDeliveryBlock: taskService.explainNativeDeliveryBlock
+        explainNativeDeliveryBlock: taskService.explainNativeDeliveryBlock,
+        isRedeliveryExhausted: (taskId) => taskService.isRedeliveryExhausted({ chatroomId: firstTask.chatroomId, role, taskId })
       });
       const attemptId = `${Date.now()}-${firstTask.taskId}`;
       const decisionReason = "reason" in decision ? decision.reason : undefined;
@@ -47465,6 +47733,7 @@ var init_task_service2 = __esm(() => {
   init_native_task_injector_logic();
   init_task_service();
   init_convex_native_task_delivery_gateway();
+  init_task_handoff_repository();
   init_daemon_audit_port();
   init_native_task_delivery_coordinator();
 });
@@ -47567,6 +47836,7 @@ class AgentWorkManager {
   unsubscribeAgentTurnEnded;
   unsubscribeAgentStarted;
   unsubscribeAgentSessionLost;
+  unsubscribeAgentTurnProgress;
   reconcileStates = new Map;
   unsubscribeTaskService;
   nativeTaskDeliveryQueue;
@@ -47599,16 +47869,33 @@ class AgentWorkManager {
       releaseTaskAfterTurnFailure: deps.taskService.releaseTaskAfterTurnFailure,
       recordDeliveryFailure: deps.taskService.recordDeliveryFailure,
       clearDeliveryFailure: deps.taskService.clearDeliveryFailure,
+      recordUncoveredTurnEnd: deps.taskService.recordUncoveredTurnEnd,
+      isRedeliveryExhausted: deps.taskService.isRedeliveryExhausted,
+      clearRedeliveryTracking: deps.taskService.clearRedeliveryTracking,
       loadAssignedTaskForAction: deps.taskService.loadAssignedTaskForAction,
       deliverNativeTask: (task, harnessSessionId, onTaskDelivered) => this.nativeTaskDeliveryQueue.enqueue({ task, harnessSessionId, onTaskDelivered })
     };
     this.unsubscribeAgentTurnEnded = deps.agentMgr.subscribeAgentTurnEnded((event) => this.handleAgentTurnEnded(event));
     this.unsubscribeAgentStarted = deps.agentMgr.subscribeAgentStarted((event) => this.handleAgentStarted(event));
     this.unsubscribeAgentSessionLost = deps.agentMgr.subscribeAgentSessionLost((event) => this.handleAgentSessionLost(event));
+    this.unsubscribeAgentTurnProgress = deps.agentMgr.subscribeAgentTurnProgress((event) => {
+      const activeTask = this.deps.agentTaskState.get(event);
+      if (!activeTask)
+        return;
+      this.deps.taskService.handleAgentTurnProgress({ ...event, taskId: activeTask.taskId }).catch((error51) => {
+        console.warn(`[AgentProcessManager] turn-progress handling failed for ${event.role}@${event.chatroomId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      });
+    });
     this.unsubscribeTaskService = deps.taskService.subscribe((notification) => this.handleTaskServiceNotification(notification));
   }
   async handleAgentStarted(event) {
     this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+    if (event.reason === "user.start") {
+      this.deps.taskService.clearRedeliveryTracking({
+        chatroomId: event.chatroomId,
+        role: event.role
+      });
+    }
     await this.requestReconcile({
       chatroomId: event.chatroomId,
       role: event.role,
@@ -47626,24 +47913,43 @@ class AgentWorkManager {
       console.warn(`[NativeDelivery:failure] role=${event.role} chatroom=${event.chatroomId} operation=session-loss-reconcile error=${error51 instanceof Error ? error51.message : String(error51)}`);
     });
   }
+  async recoverTaskAfterUncoveredTurnEnd(event, activeTask, phase) {
+    const { chatroomId, role } = event;
+    const { exceeded } = await this.deps.taskService.recordUncoveredTurnEnd({
+      chatroomId,
+      role,
+      taskId: activeTask.taskId
+    });
+    if (exceeded)
+      return "exceeded";
+    try {
+      await this.deps.taskService.releaseTaskAfterTurnFailure({
+        chatroomId,
+        role,
+        taskId: activeTask.taskId
+      });
+    } catch (error51) {
+      console.error(`[NativeDelivery:${phase}-recovery-error] chatroom=${chatroomId} role=${role} task=${activeTask.taskId} turn=${event.completion.turnId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      return "recovery-failed";
+    }
+    return "released";
+  }
   async handleAgentTurnEnded(event) {
     const completion = event.completion;
     if (completion.status !== "completed") {
-      const activeTask = this.deps.agentTaskState.get({
+      const activeTask2 = 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 (error51) {
-          console.error(`[NativeDelivery:turn-failed-recovery-error] chatroom=${event.chatroomId} role=${event.role} task=${activeTask.taskId} turn=${completion.turnId} error=${error51 instanceof Error ? error51.stack ?? error51.message : String(error51)}`);
+      console.error(`[NativeDelivery:turn-failed] chatroom=${event.chatroomId} role=${event.role} task=${activeTask2?.taskId ?? "none"} turn=${completion.turnId} status=${completion.status} source=${completion.source} error=${errorDetail ?? "none"}`);
+      if (activeTask2) {
+        const recovery = await this.recoverTaskAfterUncoveredTurnEnd(event, activeTask2, "turn-failed");
+        if (recovery === "exceeded") {
+          this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+          return { kind: "release-slot" };
+        }
+        if (recovery === "recovery-failed") {
           return { kind: "hold-slot", reason: "task-recovery-failed" };
         }
         this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
@@ -47652,7 +47958,7 @@ class AgentWorkManager {
         kind: "turn_failed",
         chatroomId: event.chatroomId,
         role: event.role,
-        ...activeTask?.taskId ? { taskId: activeTask.taskId } : {},
+        ...activeTask2?.taskId ? { taskId: activeTask2.taskId } : {},
         ...event.slot.harnessSessionId ? { harnessSessionId: event.slot.harnessSessionId } : {},
         turnId: completion.turnId,
         status: completion.status,
@@ -47672,6 +47978,19 @@ class AgentWorkManager {
       }
       return { kind: "release-slot" };
     }
+    const activeTask = this.deps.agentTaskState.get({
+      chatroomId: event.chatroomId,
+      role: event.role
+    });
+    if (activeTask) {
+      const handoff = await this.deps.taskService.getLatestHandoff(event.chatroomId, event.role);
+      if (!handoff?.taskIds.includes(activeTask.taskId)) {
+        const recovery = await this.recoverTaskAfterUncoveredTurnEnd(event, activeTask, "turn-ended");
+        if (recovery === "recovery-failed") {
+          return { kind: "hold-slot", reason: "task-recovery-failed" };
+        }
+      }
+    }
     this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
     try {
       await this.deps.lifecycleOutbox.enqueue(buildAgentStatusFact({
@@ -47696,6 +48015,7 @@ class AgentWorkManager {
     this.unsubscribeAgentTurnEnded();
     this.unsubscribeAgentStarted();
     this.unsubscribeAgentSessionLost();
+    this.unsubscribeAgentTurnProgress();
     this.unsubscribeTaskService?.();
     this.unsubscribeTaskService = undefined;
     this.nativeTaskDeliveryQueue.stop();
@@ -47809,6 +48129,11 @@ class AgentWorkManager {
     });
     return delivered;
   }
+  async handleAgentRestart(args2) {
+    resetRoleDeliveryState(args2.chatroomId, args2.role);
+    this.deps.agentTaskState.clear(args2);
+    await this.deps.taskService.handleAgentRestart(args2);
+  }
   async requestReconcileForTasks(tasks, source) {
     const roles = new Set(tasks.map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
     await Promise.all([...roles].map((key) => {
@@ -47844,6 +48169,7 @@ var init_agent_work_manager = __esm(() => {
   init_native_task_injector_logic();
   init_convex_native_task_delivery_gateway();
   init_daemon_audit_port();
+  init_native_task_delivery_coordinator();
   init_task_delivery_processor();
   init_native_task_injector();
 });
@@ -50852,12 +51178,12 @@ var init_model_provider = () => {};
 // src/daemon/infrastructure/local/harness/services/cursor-sdk/cursor-sdk-package.ts
 import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname2, join as join8 } from "node:path";
+import { dirname as dirname3, join as join8 } from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 function resolveChatroomCliRoot(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath2(moduleRef) : moduleRef;
-  let dir = dirname2(filePath);
-  while (dir !== dirname2(dir)) {
+  let dir = dirname3(filePath);
+  while (dir !== dirname3(dir)) {
     const packageJsonPath = join8(dir, "package.json");
     if (existsSync2(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
@@ -50865,7 +51191,7 @@ function resolveChatroomCliRoot(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname2(dir);
+    dir = dirname3(dir);
   }
   throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT}`);
 }
@@ -50880,7 +51206,7 @@ function readPinnedSdkVersion(chatroomCliRoot) {
   return match17[1];
 }
 function readInstalledSdkVersion(entryPath) {
-  const packageJsonPath = join8(dirname2(entryPath), "..", "..", "package.json");
+  const packageJsonPath = join8(dirname3(entryPath), "..", "..", "package.json");
   const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -51781,12 +52107,12 @@ var init_claude = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/claude-sdk/claude-sdk-package.ts
 import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname3, join as join9 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
-  let dir = dirname3(filePath);
-  while (dir !== dirname3(dir)) {
+  let dir = dirname4(filePath);
+  while (dir !== dirname4(dir)) {
     const packageJsonPath = join9(dir, "package.json");
     if (existsSync3(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
@@ -51794,7 +52120,7 @@ function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname3(dir);
+    dir = dirname4(dir);
   }
   throw new ClaudeSdkPackageError(`Could not locate chatroom-cli package root while resolving ${CLAUDE_AGENT_SDK_PKG}. ${REINSTALL_HINT2}`);
 }
@@ -51809,7 +52135,7 @@ function readPinnedSdkVersion2(chatroomCliRoot) {
   return match17[1];
 }
 function readInstalledSdkVersion2(entryPath) {
-  const packageJsonPath = join9(dirname3(entryPath), "package.json");
+  const packageJsonPath = join9(dirname4(entryPath), "package.json");
   const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -51835,7 +52161,7 @@ function resolveNativeCliBinaryPath(sdkEntryPath) {
   const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
   let pkgDir;
   try {
-    pkgDir = dirname3(require3.resolve(`${platformPkg}/package.json`));
+    pkgDir = dirname4(require3.resolve(`${platformPkg}/package.json`));
   } catch {
     throw new ClaudeSdkPackageError(`Native CLI binary package ${platformPkg} is not installed. ${REINSTALL_HINT2}`);
   }
@@ -52771,12 +53097,12 @@ var init_codex_sdk_model_variants = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-package.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6, realpathSync, statSync } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
-  let dir = dirname4(filePath);
-  while (dir !== dirname4(dir)) {
+  let dir = dirname5(filePath);
+  while (dir !== dirname5(dir)) {
     const packageJsonPath = join10(dir, "package.json");
     if (existsSync4(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
@@ -52784,7 +53110,7 @@ function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname4(dir);
+    dir = dirname5(dir);
   }
   throw new CodexSdkPackageError(`Could not locate chatroom-cli package root while resolving @openai/codex-sdk. ${REINSTALL_HINT3}`);
 }
@@ -52851,7 +53177,7 @@ function addPlatformPackageJsonCandidate(candidates, candidate) {
 }
 function resolvePlatformPackageJsonCandidates(platformPkg, chatroomCliRoot, codexPackageJson, chatroomRequire, codexRequire) {
   const candidates = [];
-  const codexPackageDir = realpathSync(dirname4(codexPackageJson));
+  const codexPackageDir = realpathSync(dirname5(codexPackageJson));
   const platformPkgBaseName = platformPkg.includes("/") ? platformPkg.slice(platformPkg.indexOf("/") + 1) : platformPkg;
   try {
     addPlatformPackageJsonCandidate(candidates, codexRequire.resolve(`${platformPkg}/package.json`));
@@ -52895,7 +53221,7 @@ function resolveCodexExecutablePath(moduleRef = import.meta.url) {
     throw new CodexSdkPackageError(`Native Codex CLI package ${platformPkg} is not installed. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies. ${REINSTALL_HINT3}`);
   }
   for (const platformPackageJson of platformPackageJsonCandidates) {
-    const vendorRoot = join10(dirname4(platformPackageJson), "vendor");
+    const vendorRoot = join10(dirname5(platformPackageJson), "vendor");
     const binaryPath = resolveNativeCodexBinary(vendorRoot, targetTriple, codexBinaryName);
     if (binaryPath) {
       return binaryPath;
@@ -52911,7 +53237,7 @@ async function importBundledCodexSdk(moduleRef = import.meta.url) {
   if (installedVersion !== pinnedVersion) {
     throw new CodexSdkPackageError(`@openai/codex-sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
   }
-  const distEntryPath = join10(dirname4(packageJsonPath), "dist", "index.js");
+  const distEntryPath = join10(dirname5(packageJsonPath), "dist", "index.js");
   if (!existsSync4(distEntryPath)) {
     throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${distEntryPath}. ${REINSTALL_HINT3}`);
   }
@@ -55022,9 +55348,9 @@ var init_session_event_forwarder = __esm(() => {
 });
 
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/session-metadata-store.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname5, join as join11 } from "node:path";
+import { dirname as dirname6, join as join11 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
@@ -55041,9 +55367,9 @@ class FileSessionMetadataStore {
   }
   save(sessions) {
     try {
-      const dir = dirname5(this.filePath);
+      const dir = dirname6(this.filePath);
       if (!existsSync5(dir)) {
-        mkdirSync2(dir, { recursive: true });
+        mkdirSync3(dir, { recursive: true });
       }
       writeFileSync2(this.filePath, JSON.stringify(sessions, null, 2));
     } catch {}
@@ -55591,12 +55917,12 @@ var init_opencode_sdk = __esm(() => {
 
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-package.ts
 import { existsSync as existsSync6, readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname7, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
 function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath5(moduleRef) : moduleRef;
-  let dir = dirname6(filePath);
-  while (dir !== dirname6(dir)) {
+  let dir = dirname7(filePath);
+  while (dir !== dirname7(dir)) {
     const packageJsonPath = join12(dir, "package.json");
     if (existsSync6(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
@@ -55604,7 +55930,7 @@ function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT4}`);
 }
@@ -55619,18 +55945,18 @@ function readPinnedSdkVersion4(chatroomCliRoot) {
   return match17[1];
 }
 function readInstalledSdkVersion4(entryPath) {
-  const packageJsonPath = join12(dirname6(entryPath), "..", "package.json");
+  const packageJsonPath = join12(dirname7(entryPath), "..", "package.json");
   const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot) {
   let dir = chatroomCliRoot;
-  while (dir !== dirname6(dir)) {
+  while (dir !== dirname7(dir)) {
     const entryPath = join12(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
     if (existsSync6(entryPath)) {
       return entryPath;
     }
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   return;
 }
@@ -63776,15 +64102,35 @@ async function requestLocalDaemon(port, event, payload) {
       socket.connect();
     });
     const response = await socket.timeout(1e4).emitWithAck(event, payload);
-    if (!response.ok)
-      throw new Error(response.error?.message ?? `Daemon request failed: ${event}`);
+    if (!response.ok) {
+      throw toLocalDaemonServerError(response, event);
+    }
     return response.data;
   } finally {
     socket.disconnect();
   }
 }
+function toLocalDaemonServerError(response, event) {
+  const error51 = response.error ?? {};
+  return new LocalDaemonServerError({
+    message: error51.message ?? `Daemon request failed: ${event}`,
+    code: error51.code,
+    details: error51.details
+  });
+}
+var LocalDaemonServerError;
 var init_local_daemon = __esm(() => {
   init_esm_debug3();
+  LocalDaemonServerError = class LocalDaemonServerError extends Error {
+    code;
+    details;
+    constructor(error51) {
+      super(error51.message ?? "Daemon request failed");
+      this.name = "LocalDaemonServerError";
+      this.code = error51.code;
+      this.details = error51.details;
+    }
+  };
 });
 
 // src/daemon/entry/resolve-local-web-port.ts
@@ -63996,12 +64342,12 @@ var init_log_schema = __esm(() => {
 });
 
 // src/infrastructure/log-server/open-log-database.ts
-import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function openLogDatabase(dbPath) {
-  mkdirSync3(dirname7(dbPath), { recursive: true });
-  const db = new DatabaseSync(dbPath);
+  mkdirSync4(dirname8(dbPath), { recursive: true });
+  const db = new DatabaseSync2(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA synchronous = NORMAL");
@@ -64190,7 +64536,7 @@ var init_daemon_process_scan = __esm(() => {
 
 // src/commands/machine/pid.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join16 } from "node:path";
 function getUrlHash2() {
@@ -64202,7 +64548,7 @@ function getPidFileName() {
 }
 function ensureChatroomDir2() {
   if (!existsSync8(CHATROOM_DIR3)) {
-    mkdirSync4(CHATROOM_DIR3, { recursive: true, mode: 448 });
+    mkdirSync5(CHATROOM_DIR3, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
@@ -77212,11 +77558,11 @@ var init_pdfium_renderer = __esm(() => {
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/engines/pdf/pdfjsImporter.js
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 async function importPdfJs() {
   const pdfUrl = new URL("../../vendor/pdfjs/pdf.mjs", import.meta.url);
   const pdfjs = await import(pdfUrl.href);
-  const dirPath = dirname8(fileURLToPath6(pdfUrl));
+  const dirPath = dirname9(fileURLToPath6(pdfUrl));
   return {
     fn: pdfjs.getDocument,
     dir: dirPath
@@ -98865,9 +99211,9 @@ function applyMarkupTags(markup, text) {
 }
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/processing/gridDebugLogger.js
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 
 class GridDebugLogger {
   config;
@@ -99194,14 +99540,14 @@ class GridDebugLogger {
   flushSync() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    mkdirSync5(dirname9(this.config.outputPath), { recursive: true });
+    mkdirSync6(dirname10(this.config.outputPath), { recursive: true });
     writeFileSync4(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
   async flush() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    await mkdir4(dirname9(this.config.outputPath), { recursive: true });
+    await mkdir4(dirname10(this.config.outputPath), { recursive: true });
     await writeFile5(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
@@ -99252,7 +99598,7 @@ var init_gridDebugLogger = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/processing/gridVisualizer.js
-import { mkdirSync as mkdirSync6 } from "fs";
+import { mkdirSync as mkdirSync7 } from "fs";
 function escapeXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -99362,7 +99708,7 @@ async function renderGridVisualization(data, outputPath) {
   }).composite([{ input: svgBuffer, top: 0, left: 0 }]).png({ compressionLevel: 6 }).toFile(outputPath);
 }
 async function renderAllVisualizations(pages, outputDir) {
-  mkdirSync6(outputDir, { recursive: true });
+  mkdirSync7(outputDir, { recursive: true });
   const paths = [];
   for (const page of pages) {
     const filePath = `${outputDir}/page-${page.pageNum}-grid.png`;
@@ -107065,6 +107411,9 @@ function getFrontendDesignUxFlowChecklistBlock() {
 - **Interaction affordance:** pointer cursor (or project equivalent) on clickable elements
 - **Safeguards:** confirmation before destructive actions; bulk operations confirmed with scope summary`;
 }
+function getFrontendDesignUxTriggerDescription() {
+  return "when the user request involves user interface changes";
+}
 
 // ../../services/backend/prompts/utils/enhancer-feedback-template-body.ts
 function getEnhancerFeedbackTemplateBody() {
@@ -107927,31 +108276,8 @@ function formatDecodeError(error51) {
   return message;
 }
 
-// ../../services/backend/prompts/native/session-continuity.ts
-function getNativeHandoffTurnEndGuidance(nextRole) {
-  return getHandoffTurnEndGuidance(nextRole);
-}
-function getHandoffTurnEndGuidance(nextRole) {
-  const lines = [
-    "",
-    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**"
-  ];
-  if (nextRole.toLowerCase() === "user") {
-    lines.push("The system delivers the next chatroom task when the user sends one.");
-  } else {
-    lines.push(`The system delivers \`${nextRole}\`'s handback when they finish — do not poll \`messages download\` while waiting. For history reconstruction tasks, \`messages download\` is the correct tool.`);
-  }
-  return lines.join(`
-`);
-}
-function getNativeEnhancerRequestTurnEndGuidance() {
-  return [
-    "",
-    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**",
-    "Do **not** wait for enhancer input, poll, or monitor the enhancer job in this turn. The system delivers independent planning input as your next task when analysis completes."
-  ].join(`
-`);
-}
+// ../../services/backend/prompts/config/agent-general-knowledge.ts
+var init_agent_general_knowledge = () => {};
 // ../../services/backend/prompts/sections/activated-skills.ts
 var init_activated_skills = () => {};
 
@@ -108062,6 +108388,74 @@ var init_general_knowledge = __esm(() => {
   init_utils3();
 });
 
+// ../../services/backend/prompts/enhancer/system-prompt.ts
+var ENHANCER_ROLE_CONTRACT_LINES;
+var init_system_prompt = __esm(() => {
+  init_stdin_heredoc();
+  init_agent_general_knowledge();
+  init_general_knowledge();
+  ENHANCER_ROLE_CONTRACT_LINES = [
+    "You are a single-turn, memoryless **design advisor**. Produce a high-intelligence first design for the user request; you are not an implementer.",
+    "",
+    "## Your role",
+    "- Recover the authoritative user request and relevant history before analysis.",
+    "- Inspect the repository and closely related files to understand existing patterns, constraints, and likely change surfaces.",
+    "- Return **one** complete recommended design — not multiple options. The entry point verifies and delegates.",
+    "- Complete frontend and data/query design sections at code granularity before implementation sequencing.",
+    "- Use <additional-context> from the forwarded request as the entry point's goal; verify against downloaded history and repository evidence.",
+    "- <user-message> is authoritative for what the user said; do not treat <additional-context> as a substitute.",
+    "- Give concrete, evidence-backed design input with repo-relative file references and targeted code snippets when useful.",
+    "- In <handoff-proofs>, complete **Proof of Principles** for how this design satisfies each quality principle.",
+    "- Keep the user request as the north star. Tighten within its scope; do not invent requirements.",
+    "- Your output becomes the first planning input to the stateful team entry point, which owns persistent memory, the ongoing plan, and execution.",
+    "",
+    `## Frontend design (${getFrontendDesignUxTriggerDescription()})`,
+    "- Complete <handoff-frontend-design> with flows, per-flow UX quality checklist, component specs, and layout at code granularity.",
+    "- Ground patterns in repository evidence — cite existing components; recommend one when multiple exist.",
+    '- Write "Not Applicable." for the entire section when no UI changes are involved.',
+    "",
+    "## Large or multi-surface revisions",
+    "- When the request involves refactoring, consolidation, or consistency across many surfaces, note in implementation sequence that the entry point should run `chatroom skill activate defragmentation` before delegating slices.",
+    "",
+    "## Data and query design (when persistence or query patterns change)",
+    "- Complete <handoff-data-design> with schema, indexes, and query patterns within project limits.",
+    '- Write "Not Applicable." for the entire section when no persistence changes are involved.',
+    "",
+    "## What you must NOT do",
+    "- Do NOT implement changes, spawn subagents, or expand scope.",
+    "- Do NOT propose multiple alternative approaches — one recommended design only.",
+    "- Do NOT produce generic advice. Tie findings to user messages, repository evidence, and named files.",
+    "- Do NOT treat <forwarded-request> as the only source of context; download message history first.",
+    "- Output must match <output-template>. **Recommended implementation sequence** and **Files touched** are the last sections."
+  ];
+});
+
+// ../../services/backend/prompts/native/session-continuity.ts
+function getNativeHandoffTurnEndGuidance(nextRole) {
+  return getHandoffTurnEndGuidance(nextRole);
+}
+function getHandoffTurnEndGuidance(nextRole) {
+  const lines = [
+    "",
+    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**"
+  ];
+  if (nextRole.toLowerCase() === "user") {
+    lines.push("The system delivers the next chatroom task when the user sends one.");
+  } else {
+    lines.push(`The system delivers \`${nextRole}\`'s handback when they finish — do not poll \`messages download\` while waiting. For history reconstruction tasks, \`messages download\` is the correct tool.`);
+  }
+  return lines.join(`
+`);
+}
+function getNativeEnhancerRequestTurnEndGuidance() {
+  return [
+    "",
+    "**Handoff complete. End your turn now — stop tool calls. The system will send you a message when further action is required.**",
+    "Do **not** wait for enhancer input, poll, or monitor the enhancer job in this turn. The system delivers independent planning input as your next task when analysis completes."
+  ].join(`
+`);
+}
+
 // ../../services/backend/prompts/cli/handoff/command.ts
 var init_command3 = __esm(() => {
   init_stdin_heredoc();
@@ -108098,18 +108492,6 @@ var init_builder2 = __esm(() => {
   init_sections();
 });
 
-// ../../services/backend/prompts/enhancer/history-retrieval.ts
-var init_history_retrieval = __esm(() => {
-  init_guidance();
-});
-
-// ../../services/backend/prompts/cli/roles/enhancer.ts
-var init_enhancer3 = __esm(() => {
-  init_history_retrieval();
-  init_env();
-  init_sections();
-});
-
 // ../../services/backend/prompts/cli/roles/planner.ts
 var init_planner2 = __esm(() => {
   init_env();
@@ -108127,12 +108509,18 @@ var init_solo2 = __esm(() => {
   init_sections();
 });
 
-// ../../services/backend/prompts/cli/roles/fromContext.ts
+// ../../services/backend/prompts/teams/solo/prompts/fromContext.ts
 var init_fromContext = __esm(() => {
+  init_solo2();
+});
+
+// ../../services/backend/prompts/cli/roles/fromContext.ts
+var init_fromContext2 = __esm(() => {
   init_builder2();
-  init_enhancer3();
   init_planner2();
-  init_solo2();
+  init_system_prompt();
+  init_fromContext();
+  init_utils3();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/builder.ts
@@ -108147,20 +108535,15 @@ var init_planner3 = __esm(() => {
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/fromContext.ts
-var init_fromContext2 = __esm(() => {
+var init_fromContext3 = __esm(() => {
   init_builder3();
   init_planner3();
 });
-
-// ../../services/backend/prompts/teams/solo/prompts/fromContext.ts
-var init_fromContext3 = __esm(() => {
-  init_solo2();
-});
 // ../../services/backend/prompts/selector-context.ts
 var init_selector_context = __esm(() => {
-  init_fromContext();
   init_fromContext2();
   init_fromContext3();
+  init_fromContext();
 });
 
 // ../../services/backend/prompts/sections/role-guidance.ts
@@ -108177,12 +108560,14 @@ var init_role_identity = __esm(() => {
 });
 
 // ../../services/backend/prompts/native/system-prompt.ts
-var init_system_prompt = __esm(() => {
+var init_system_prompt2 = __esm(() => {
+  init_system_prompt();
   init_commands_reference();
   init_general_knowledge();
   init_role_guidance();
   init_role_identity();
   init_selector_context();
+  init_utils3();
 });
 
 // ../../services/backend/prompts/native/task-started-content.ts
@@ -108265,6 +108650,7 @@ var init_generator = __esm(() => {
   init_command();
   init_reminder();
   init_system_prompt();
+  init_system_prompt2();
   init_classification_guide();
   init_commands_reference();
   init_general_knowledge();
@@ -108280,6 +108666,21 @@ var init_generator = __esm(() => {
   init_review_guidelines();
 });
 
+// src/infrastructure/cli-gateway/local-handoff-gateway.ts
+function createLocalHandoffGateway() {
+  return {
+    handoff: (args2) => requestLocalDaemon(resolveLocalWebPort(), "cli.handoff", args2).catch((error51) => {
+      if (error51 instanceof LocalDaemonServerError)
+        throw error51;
+      throw new Error(`CLI gateway unavailable. Start the Chatroom daemon and retry. ${error51 instanceof Error ? error51.message : String(error51)}`);
+    })
+  };
+}
+var init_local_handoff_gateway = __esm(() => {
+  init_local_daemon();
+  init_resolve_local_web_port();
+});
+
 // src/infrastructure/deps/create-convex-command-deps.ts
 async function createConvexCommandDeps() {
   const client4 = await getConvexClient();
@@ -108305,7 +108706,8 @@ __export(exports_handoff, {
   handoff: () => handoff
 });
 async function createDefaultDeps10() {
-  return createConvexCommandDeps();
+  const deps = await createConvexCommandDeps();
+  return { backend: deps.backend, gateway: createLocalHandoffGateway(), session: deps.session };
 }
 function handleHandoffError(err) {
   return exports_Effect.sync(() => {
@@ -108376,27 +108778,24 @@ async function handoff(chatroomId, options, deps) {
 }
 var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const session2 = yield* SessionService;
-  const backend2 = yield* BackendService;
+  const gateway = yield* CliGatewayService;
   const { role, message, nextRole } = options;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
-  const result = yield* backend2.mutation(api.messages.handoff, {
-    sessionId,
-    chatroomId,
-    senderRole: role,
-    content: message,
-    targetRole: nextRole
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
+  const result = yield* exports_Effect.tryPromise({
+    try: () => gateway.handoff({
+      sessionId,
+      chatroomId,
+      senderRole: role,
+      content: message,
+      targetRole: nextRole
+    }),
+    catch: (cause3) => cause3 instanceof Error ? cause3 : new Error(String(cause3))
   }).pipe(exports_Effect.mapError((cause3) => {
     let errorData;
     if (cause3 instanceof ConvexError) {
       errorData = cause3.data;
+    } else if (cause3 instanceof LocalDaemonServerError && cause3.details) {
+      errorData = cause3.details;
     }
     return { _tag: "HandoffFailed", cause: cause3, errorData };
   }));
@@ -108422,7 +108821,8 @@ var init_handoff = __esm(() => {
   init_generator();
   init_values();
   init_esm();
-  init_api3();
+  init_local_daemon();
+  init_local_handoff_gateway();
   init_create_convex_command_deps();
   init_services();
   init_error_formatting();
@@ -109711,15 +110111,7 @@ async function activateSkill(chatroomId, skillId, options, deps) {
 }
 var listSkillsEffect = (chatroomId, _options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const skills = yield* backend2.query(api.skills.list, {
     sessionId,
     chatroomId
@@ -109739,15 +110131,7 @@ var listSkillsEffect = (chatroomId, _options) => exports_Effect.gen(function* ()
 }), activateSkillEffect = (chatroomId, skillId, options) => exports_Effect.gen(function* () {
   const session2 = yield* SessionService;
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const convexUrl = yield* session2.getConvexUrl();
   const result = yield* backend2.mutation(api.skills.activate, {
     sessionId,
@@ -110163,15 +110547,7 @@ var PAGE_SIZE = 50, SINCE_PAGE_SIZE = 500, ABSOLUTE_MAX = 5000, DEFAULT_LIMIT =
 }), downloadMessagesEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
   const fs11 = yield* MessagesFsService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const format4 = options.format ?? "linear";
   const maxDownload = parseLimit(options.limit);
   const outputDir = options.outputDir ?? resolveDownloadOutputDir(format4);
@@ -110442,15 +110818,7 @@ async function listSinceMessage(chatroomId, options, deps) {
 }
 var listBySenderRoleEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const messages = yield* backend2.query(api.messages.listBySenderRole, {
     sessionId,
     chatroomId,
@@ -110485,15 +110853,7 @@ var listBySenderRoleEffect = (chatroomId, options) => exports_Effect.gen(functio
   });
 }), listSinceMessageEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const messages = yield* backend2.query(api.messages.listSinceMessage, {
     sessionId,
     chatroomId,
@@ -110960,15 +111320,7 @@ async function viewManyArtifacts(chatroomId, options, deps) {
 }
 var createArtifactEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   if (!options.fromFile.endsWith(".md")) {
     return yield* exports_Effect.fail({
       _tag: "InvalidFileExtension",
@@ -111006,15 +111358,7 @@ var createArtifactEffect = (chatroomId, options) => exports_Effect.gen(function*
   return artifactId;
 }), viewArtifactEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   const artifact = yield* backend2.query(api.artifacts.get, {
     sessionId,
     artifactId: options.artifactId
@@ -111040,15 +111384,7 @@ var createArtifactEffect = (chatroomId, options) => exports_Effect.gen(function*
   });
 }), viewManyArtifactsEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect((a) => ({
-    _tag: "NotAuthenticated",
-    convexUrl: a.convexUrl,
-    otherUrls: a.otherUrls
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
   if (options.artifactIds.length === 0) {
     return yield* exports_Effect.fail({ _tag: "NoArtifactIds" });
   }
@@ -111446,12 +111782,12 @@ var init_durable_fifo_queue_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
-import { mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function openDurableFifoQueueStore(dbPath) {
-  mkdirSync7(dirname10(dbPath), { recursive: true });
-  const db = new DatabaseSync2(dbPath);
+  mkdirSync8(dirname11(dbPath), { recursive: true });
+  const db = new DatabaseSync3(dbPath);
   for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
     db.exec(sql);
   db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
@@ -111868,7 +112204,8 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry3, m
   resumeTurnForSlot: (args2) => exports_Effect.promise(() => mgr.resumeTurnForSlot(args2)),
   subscribeAgentTurnEnded: (handler) => processManagerService.subscribeAgentTurnEnded(handler),
   subscribeAgentStarted: (handler) => processManagerService.subscribeAgentStarted(handler),
-  subscribeAgentSessionLost: (handler) => processManagerService.subscribeAgentSessionLost(handler)
+  subscribeAgentSessionLost: (handler) => processManagerService.subscribeAgentSessionLost(handler),
+  subscribeAgentTurnProgress: (handler) => processManagerService.subscribeAgentTurnProgress(handler)
 }), DaemonAgentProcessManagerCommandService, DaemonAgentProcessManagerCommandServiceLive = (service4) => exports_Layer.succeed(DaemonAgentProcessManagerCommandService, service4), DaemonSessionService, DaemonMutableStateService;
 var init_daemon_services = __esm(() => {
   init_esm();
@@ -112162,6 +112499,14 @@ var init_output_store = __esm(() => {
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
+// src/daemon/entry/task-handoff-repository-path.ts
+import { homedir as homedir9 } from "node:os";
+import { join as join22 } from "node:path";
+function resolveTaskHandoffRepositoryPath(machineId) {
+  return join22(homedir9(), ".chatroom", "daemon", machineId, "task-handoffs.sqlite");
+}
+var init_task_handoff_repository_path = () => {};
+
 // src/infrastructure/services/harness-spawning/rate-limiter.ts
 class SpawnRateLimiter {
   config;
@@ -112333,9 +112678,10 @@ var init_convex_agent_config_gateway = __esm(() => {
     model: exports_external.string(),
     workingDir: exports_external.string(),
     status: exports_external.enum(WorkspaceAgentConfigInboxStatus),
-    createdAt: exports_external.number()
+    createdAt: exports_external.number(),
+    processedAt: exports_external.number().optional()
   });
-  agentConfigInboxEventSchema = agentConfigInboxRowSchema.transform(({ _id: eventId, ...row }) => ({ ...row, eventId }));
+  agentConfigInboxEventSchema = agentConfigInboxRowSchema.transform(({ _id: eventId, processedAt: _processedAt, ...row }) => ({ ...row, eventId }));
 });
 
 // src/daemon/services/chatroom-workspace-configuration-service/service/agent-config-registry.ts
@@ -112616,6 +112962,7 @@ function assembleDaemonSessionInit(args2) {
     convexUrl,
     backend: deps.backend,
     configurationService: agentConfigRegistry,
+    handoffRepository: createTaskHandoffRepository(resolveTaskHandoffRepositoryPath(machineId)),
     logEvent: activeLogEvent ?? (async () => {
       return;
     })
@@ -112656,9 +113003,6 @@ class NetworkRetryError {
     this.attempt = attempt;
   }
 }
-function getActiveLogSink() {
-  return activeLogSink;
-}
 async function initDaemon(options = {}) {
   activeLogSink = options.logSink;
   activeLogEvent = options.logEvent;
@@ -112859,6 +113203,7 @@ var init_init_daemon = __esm(() => {
   init_daemon_startup_log();
   init_orphan_tracker();
   init_output_store();
+  init_task_handoff_repository_path();
   init_pid();
   init_storage();
   init_client2();
@@ -112873,6 +113218,7 @@ var init_init_daemon = __esm(() => {
   init_agent_process_service2();
   init_chatroom_workspace_configuration_service();
   init_service_interfaces();
+  init_task_service2();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
   initDaemonEffect = exports_Effect.gen(function* () {
     const lockAcquired = yield* exports_Effect.tryPromise({
@@ -117227,16 +117573,16 @@ var MAX_NAME_LENGTH = 256;
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile7, readdir, stat as stat4 } from "node:fs/promises";
-import { join as join22, basename, resolve as resolve4 } from "node:path";
+import { join as join23, basename, resolve as resolve4 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join22(rootDir, cleaned.slice(0, -2));
+  const parentDir = join23(rootDir, cleaned.slice(0, -2));
   try {
     const entries2 = await readdir(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join22(parentDir, entry.name);
+      const dirPath = join23(parentDir, entry.name);
       if (resolve4(dirPath).startsWith(resolve4(rootDir))) {
         dirs.push(dirPath);
       }
@@ -117247,7 +117593,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join22(rootDir, cleaned);
+  const dir = join23(rootDir, cleaned);
   try {
     if (!resolve4(dir).startsWith(resolve4(rootDir)))
       return [];
@@ -117267,7 +117613,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile7(join22(dir, "package.json"), "utf-8");
+    const content = await readFile7(join23(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -117279,7 +117625,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join22(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile7(join23(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -117306,7 +117652,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile7(join22(rootDir, "package.json"), "utf-8");
+    const content = await readFile7(join23(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -117355,11 +117701,11 @@ var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2, readFile as readFile8 } from "node:fs/promises";
-import { join as join23, relative, basename as basename2 } from "node:path";
+import { join as join24, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join23(workingDir, file2));
+      await access2(join24(workingDir, file2));
       return manager;
     } catch {}
   }
@@ -117428,7 +117774,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
   let rootPackageName = basename2(workingDir);
-  const pkg = await readJsonFile(join23(workingDir, "package.json"), "root package.json");
+  const pkg = await readJsonFile(join24(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -117444,7 +117790,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join23(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join24(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -117457,7 +117803,7 @@ async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
 async function readDenoJson(workingDir) {
   const commands = [];
   for (const fileName of ["deno.json", "deno.jsonc"]) {
-    const deno = await readJsonFile(join23(workingDir, fileName), fileName);
+    const deno = await readJsonFile(join24(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
     const pkgName = deno.name ?? basename2(workingDir);
@@ -117480,7 +117826,7 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile8(join23(workingDir, fileName), "utf-8");
+      const content = await readFile8(join24(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
@@ -118055,7 +118401,7 @@ async function runRestartOrchestrator(deps, event) {
   const { chatroomId, role } = event;
   markRestartOrchestratorInFlight(chatroomId, role, event.correlationId);
   try {
-    resetRoleDeliveryState(chatroomId, role);
+    await deps.nativeDelivery.handleAgentRestart({ chatroomId, role });
     await emitPhase(deps, event, "reset");
     await emitPhase(deps, event, "spawn");
     const spawnResult = await deps.runSerializedForAgent({ chatroomId, role, workingDir: event.workingDir }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, async (ops, context5) => {
@@ -118116,7 +118462,6 @@ var init_restart_orchestrator = __esm(() => {
   init_api3();
   init_convex_error();
   init_execution_kind();
-  init_service_interfaces();
 });
 
 // src/daemon/entry/bridge/agent-control-bridge.ts
@@ -118271,19 +118616,6 @@ async function startAgent2(deps, input) {
   });
 }
 
-// src/daemon/entry/enhancer/enhancer-drain-registry.ts
-function setEnhancerDrainHandler(fn2) {
-  drainFn = fn2;
-}
-async function drainPendingEnhancerJobsIfRegistered() {
-  if (drainFn)
-    await drainFn();
-}
-function clearEnhancerDrainHandlerForTests() {
-  drainFn = null;
-}
-var drainFn = null;
-
 // src/daemon/entry/events/agent/on-request-start-agent.ts
 var onRequestStartAgentEffect = (event) => exports_Effect.gen(function* () {
   const processManagerService = yield* DaemonAgentProcessManagerCommandService;
@@ -118300,7 +118632,6 @@ var onRequestStartAgentEffect = (event) => exports_Effect.gen(function* () {
       deadline: event.deadline,
       wantResume: event.wantResume
     });
-    await drainPendingEnhancerJobsIfRegistered();
   });
 });
 var init_on_request_start_agent = __esm(() => {
@@ -118636,435 +118967,19 @@ async function dispatchCommandInboundEvent(event) {
 }
 var handler2;
 
-// src/daemon/entry/enhancer/constants.ts
-var ENHANCER_AGENT_ROLE = "enhancer", ENHANCER_AGENT_END_GRACE_MS = 3000;
-
-// src/daemon/entry/enhancer/enhancer-log.ts
-function formatEnhancerLogLine(message) {
-  const trimmed = message.trimEnd();
-  if (trimmed.startsWith(ENHANCER_LOG_PREFIX))
-    return trimmed;
-  return `${ENHANCER_LOG_PREFIX} ${trimmed}`;
-}
-function createEnhancerLogWriter(logSink, context5, clock4 = () => Date.now()) {
-  return {
-    write(message) {
-      const formatted = formatEnhancerLogLine(message);
-      logSink?.write({
-        timestamp: clock4(),
-        level: "info",
-        source: `harness:${context5.harness}`,
-        stream: "stdout",
-        message: formatted,
-        metadata: {
-          chatroomId: context5.chatroomId,
-          role: ENHANCER_AGENT_ROLE,
-          harness: context5.harness,
-          ...context5.pid !== undefined ? { pid: context5.pid } : {}
-        }
-      });
-    }
-  };
-}
-var ENHANCER_LOG_PREFIX = "[enhancer]";
-var init_enhancer_log = () => {};
-
-// src/daemon/entry/enhancer/enhancer-spawn-registry.ts
-function registerEnhancerSpawn(handle) {
-  const handles = byChatroom.get(handle.chatroomId) ?? new Set;
-  handles.add(handle);
-  byChatroom.set(handle.chatroomId, handles);
-}
-function unregisterEnhancerSpawn(handle) {
-  const handles = byChatroom.get(handle.chatroomId);
-  if (!handles)
-    return;
-  handles.delete(handle);
-  if (handles.size === 0)
-    byChatroom.delete(handle.chatroomId);
-}
-async function abortEnhancerSpawnsForChatroom(chatroomId) {
-  const handles = byChatroom.get(chatroomId);
-  if (!handles)
-    return;
-  await Promise.all([...handles].map(async (handle) => {
-    handle.abort();
-    await handle.stopProcess().catch(() => {
-      return;
-    });
-  }));
-}
-var byChatroom;
-var init_enhancer_spawn_registry = __esm(() => {
-  byChatroom = new Map;
-});
-
-// src/daemon/entry/enhancer/job-outcome-subscription.ts
-function subscribeToEnhancerJobOutcome(args2) {
-  let currentState = null;
-  let resolveOutcome = null;
-  let rejectOutcome = null;
-  let stopped = false;
-  const outcome = new Promise((resolve5, reject) => {
-    resolveOutcome = resolve5;
-    rejectOutcome = reject;
-  });
-  const unsub = args2.wsClient.onUpdate(api.web.enhancer.index.getJobOutcome, {
-    sessionId: args2.sessionId,
-    chatroomId: args2.chatroomId,
-    jobId: args2.jobId
-  }, (state) => {
-    if (stopped)
-      return;
-    if (!state) {
-      rejectOutcome?.(new Error("Enhancer job not found"));
-      resolveOutcome = null;
-      rejectOutcome = null;
-      return;
-    }
-    currentState = state;
-    if (state.status === "complete" || state.status === "failed" || state.status === "cancelled") {
-      resolveOutcome?.(state);
-      resolveOutcome = null;
-      rejectOutcome = null;
-    }
-  }, (error51) => {
-    if (stopped)
-      return;
-    rejectOutcome?.(error51);
-    resolveOutcome = null;
-    rejectOutcome = null;
-  });
-  return {
-    outcome,
-    getCurrentState: () => currentState,
-    stop: () => {
-      if (stopped)
-        return;
-      stopped = true;
-      unsub();
-      resolveOutcome = null;
-      rejectOutcome = null;
-    }
-  };
-}
-var init_job_outcome_subscription = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/entry/enhancer/wait-for-enhancer-job.ts
-async function waitForEnhancerJobResolution(params) {
-  const { sessionId, chatroomId, jobId, wsClient: wsClient2, onFailure, onSalvageComplete, log: log4, signal } = params;
-  const writeLog = (message) => log4?.write(message);
-  let outcome = null;
-  let salvagedText = "";
-  let agentEndTimer = null;
-  let resolveWait = null;
-  const waitPromise = new Promise((resolve5) => {
-    resolveWait = resolve5;
-  });
-  const subscription = subscribeToEnhancerJobOutcome({
-    wsClient: wsClient2,
-    sessionId,
-    chatroomId,
-    jobId
-  });
-  const finish = (resolution) => {
-    if (outcome)
-      return;
-    outcome = resolution;
-    resolveWait?.();
-    resolveWait = null;
-  };
-  const onAbort = () => finish("aborted");
-  if (signal?.aborted)
-    onAbort();
-  else
-    signal?.addEventListener("abort", onAbort, { once: true });
-  const failAfterAgentEnd = () => {
-    writeLog("agent_end: turn ended without complete — failing terminal");
-    onFailure("Agent exited without completing enhancer job", true);
-    finish("failed");
-  };
-  subscription.outcome.then((state) => {
-    if (outcome)
-      return;
-    const resolution = state.status === "complete" ? "complete" : "failed";
-    if (resolution === "complete")
-      writeLog(`completed job=${jobId}`);
-    finish(resolution);
-  }).catch((error51) => {
-    if (outcome)
-      return;
-    writeLog(`enhancer outcome subscription failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    onFailure("Enhancer job outcome subscription failed", false);
-    finish("failed");
-  });
-  params.onAssistantText?.((text) => {
-    salvagedText += text;
-  });
-  params.onAgentEnd?.(() => {
-    if (outcome)
-      return;
-    agentEndTimer = setTimeout(() => {
-      if (outcome)
-        return;
-      const state = subscription.getCurrentState();
-      if (state?.status === "complete") {
-        finish("complete");
-        return;
-      }
-      if (state?.status !== "running") {
-        failAfterAgentEnd();
-        return;
-      }
-      const trimmed = salvagedText.trim();
-      if (!trimmed || !onSalvageComplete) {
-        failAfterAgentEnd();
-        return;
-      }
-      onSalvageComplete(trimmed).catch(() => {
-        failAfterAgentEnd();
-      });
-    }, ENHANCER_AGENT_END_GRACE_MS);
-  });
-  params.onExit(() => {
-    if (outcome)
-      return;
-    onFailure("Agent process exited without completing enhancer job", false);
-    finish("failed");
-  });
-  await waitPromise;
-  if (agentEndTimer)
-    clearTimeout(agentEndTimer);
-  subscription.stop();
-  signal?.removeEventListener("abort", onAbort);
-  return outcome ?? "failed";
-}
-var init_wait_for_enhancer_job = __esm(() => {
-  init_job_outcome_subscription();
-});
-
-// src/daemon/entry/enhancer-inbound-registry.ts
-function registerEnhancerInboundHandler(h) {
+// src/daemon/entry/file-inbound-registry.ts
+function registerFileInboundHandler(h) {
   handler3 = h;
 }
-function unregisterEnhancerInboundHandler() {
+function unregisterFileInboundHandler() {
   handler3 = undefined;
 }
-async function dispatchEnhancerInboundEvent(event) {
+async function dispatchFileInboundEvent(event) {
   if (handler3)
     await handler3(event);
 }
 var handler3;
 
-// src/daemon/entry/enhancer/job-subscriber.ts
-async function processEnhancerJobForSpawn(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, job, inFlight2, logSink) {
-  if (inFlight2.has(job.jobId))
-    return;
-  if (isChatroomStopScopeActive(job.chatroomId))
-    return;
-  inFlight2.add(job.jobId);
-  let claimed = false;
-  let chatroomId = job.chatroomId;
-  let jobId = job.jobId;
-  let spawnResult = null;
-  let service4 = null;
-  let abortController = null;
-  let spawnHandle = null;
-  let agentEndSeen = false;
-  let resolveAgentEnd;
-  let agentEndPromise = Promise.resolve();
-  let log4 = createEnhancerLogWriter(logSink, {
-    chatroomId: job.chatroomId,
-    harness: "unknown"
-  });
-  try {
-    const claim = await backend2.mutation(api.daemon.enhancer.index.claimForSpawn, {
-      sessionId,
-      jobId: job.jobId,
-      machineId
-    });
-    if (!claim.claimed)
-      return;
-    claimed = true;
-    log4.write(`claimed job=${job.jobId} chatroom=${job.chatroomId}`);
-    const payload = await backend2.query(api.daemon.enhancer.index.getTaskDeliveryForJob, {
-      sessionId,
-      jobId: job.jobId,
-      convexUrl
-    });
-    chatroomId = payload.chatroomId;
-    jobId = payload.jobId;
-    log4 = createEnhancerLogWriter(logSink, {
-      chatroomId: payload.chatroomId,
-      harness: payload.agentHarness,
-      pid: undefined
-    });
-    log4.write(`spawning harness=${payload.agentHarness} model=${payload.model} job=${payload.jobId}`);
-    service4 = agentServices.get(payload.agentHarness) ?? null;
-    if (!service4) {
-      await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
-        sessionId,
-        chatroomId: payload.chatroomId,
-        jobId: payload.jobId,
-        error: `Harness ${payload.agentHarness} not available on machine`
-      });
-      return;
-    }
-    const spawned = await service4.spawn({
-      workingDir: payload.workingDir,
-      prompt: createSpawnPrompt(payload.taskDeliveryOutput),
-      systemPrompt: payload.systemPrompt,
-      model: payload.model,
-      context: {
-        machineId,
-        chatroomId: payload.chatroomId,
-        role: ENHANCER_AGENT_ROLE
-      },
-      resolvedConvexUrl: convexUrl
-    });
-    spawnResult = spawned;
-    abortController = new AbortController;
-    spawnHandle = {
-      jobId: payload.jobId,
-      chatroomId: payload.chatroomId,
-      abort: () => abortController?.abort(),
-      stopProcess: async () => {
-        await service4?.stop(spawned.pid);
-      }
-    };
-    registerEnhancerSpawn(spawnHandle);
-    log4 = createEnhancerLogWriter(logSink, {
-      chatroomId: payload.chatroomId,
-      harness: payload.agentHarness,
-      pid: spawned.pid
-    });
-    spawned.onLogLine?.((line) => {
-      log4.write(line);
-    });
-    agentEndPromise = new Promise((resolve5) => {
-      resolveAgentEnd = resolve5;
-    });
-    spawned.onAgentEnd?.(() => {
-      if (agentEndSeen)
-        return;
-      agentEndSeen = true;
-      resolveAgentEnd?.();
-    });
-    await waitForEnhancerJobResolution({
-      sessionId,
-      chatroomId: payload.chatroomId,
-      jobId: payload.jobId,
-      wsClient: wsClient2,
-      log: log4,
-      onAssistantText: spawned.onAssistantText ? (cb) => spawned.onAssistantText?.(cb) : undefined,
-      onAgentEnd: spawned.onAgentEnd ? (cb) => spawned.onAgentEnd?.(cb) : undefined,
-      onExit: (cb) => spawned.onExit(() => cb()),
-      onSalvageComplete: async (content) => {
-        await backend2.mutation(api.web.enhancer.index.complete, {
-          sessionId,
-          chatroomId: payload.chatroomId,
-          jobId: payload.jobId,
-          enhancedContent: content
-        });
-      },
-      onFailure: async (error51, forceTerminal) => {
-        await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
-          sessionId,
-          chatroomId: payload.chatroomId,
-          jobId: payload.jobId,
-          error: error51,
-          ...forceTerminal ? { forceTerminal: true } : {}
-        });
-      },
-      signal: abortController.signal
-    });
-    if (!abortController.signal.aborted)
-      log4.write(`completed job=${jobId}`);
-  } catch (err) {
-    log4.write(`error: ${err instanceof Error ? err.message : String(err)}`);
-    if (claimed) {
-      await backend2.mutation(api.web.enhancer.index.recordAttemptFailure, {
-        sessionId,
-        chatroomId,
-        jobId,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  } finally {
-    inFlight2.delete(job.jobId);
-    if (spawnHandle)
-      unregisterEnhancerSpawn(spawnHandle);
-    if (spawnResult && service4) {
-      if (!agentEndSeen)
-        await Promise.race([
-          agentEndPromise,
-          new Promise((resolve5) => setTimeout(resolve5, ENHANCER_AGENT_END_GRACE_MS))
-        ]);
-      try {
-        await service4.stop(spawnResult.pid);
-      } catch {}
-    }
-  }
-}
-function processEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, jobs, inFlight2, logSink) {
-  for (const job of jobs ?? []) {
-    processEnhancerJobForSpawn(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, job, inFlight2, logSink);
-  }
-}
-async function drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2, logSink) {
-  const jobs = await backend2.query(api.daemon.enhancer.index.pendingForMachine, {
-    sessionId,
-    machineId
-  });
-  if (!jobs?.length)
-    return;
-  processEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, jobs, inFlight2, logSink);
-}
-function startEnhancerJobSubscriber(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, logSink) {
-  const inFlight2 = new Set;
-  registerEnhancerInboundHandler(async () => {
-    await drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2, logSink);
-  });
-  setEnhancerDrainHandler(() => drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2, logSink));
-  return {
-    stop: () => {
-      unregisterEnhancerInboundHandler();
-      clearEnhancerDrainHandlerForTests();
-    },
-    drainPendingEnhancerJobs: () => drainPendingEnhancerJobs(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, inFlight2, logSink)
-  };
-}
-var init_job_subscriber = __esm(() => {
-  init_enhancer_log();
-  init_enhancer_spawn_registry();
-  init_wait_for_enhancer_job();
-  init_api3();
-  init_service_interfaces();
-});
-
-// src/daemon/entry/enhancer/start-subscriptions.ts
-function startEnhancerSubscriptions(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, logSink) {
-  return startEnhancerJobSubscriber(sessionId, machineId, convexUrl, wsClient2, backend2, agentServices, logSink);
-}
-var init_start_subscriptions2 = __esm(() => {
-  init_job_subscriber();
-});
-
-// src/daemon/entry/file-inbound-registry.ts
-function registerFileInboundHandler(h) {
-  handler4 = h;
-}
-function unregisterFileInboundHandler() {
-  handler4 = undefined;
-}
-async function dispatchFileInboundEvent(event) {
-  if (handler4)
-    await handler4(event);
-}
-var handler4;
-
 // src/daemon/entry/files/file-content-classifier.ts
 function extensionOf(path3) {
   const lastDot = path3.lastIndexOf(".");
@@ -119183,7 +119098,7 @@ var init_assert_registered_working_dir = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath } from "node:fs/promises";
-import { dirname as dirname11, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
+import { dirname as dirname12, isAbsolute, relative as relative2, resolve as resolve5, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -119211,7 +119126,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname11(candidate);
+  let current = dirname12(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath(current);
@@ -119229,7 +119144,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname11(current);
+      const parent = dirname12(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -120033,16 +119948,16 @@ var require_ignore = __commonJS((exports, module) => {
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 import path3 from "node:path";
 function normalizeRelativePath(relativePath) {
   return relativePath.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+$/, "");
 }
 function expandUserPath(filePath) {
   if (filePath === "~")
-    return homedir9();
+    return homedir10();
   if (filePath.startsWith("~/"))
-    return path3.join(homedir9(), filePath.slice(2));
+    return path3.join(homedir10(), filePath.slice(2));
   return filePath;
 }
 function readExcludesFileFromGitconfig(content) {
@@ -120073,11 +119988,11 @@ async function readGitconfigExcludesFilePath(configPath) {
   return path3.isAbsolute(raw) ? expandUserPath(raw) : path3.resolve(path3.dirname(configPath), raw);
 }
 async function resolveGitExtraExcludeFilePaths(rootDir) {
-  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir9(), ".gitconfig");
+  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir10(), ".gitconfig");
   const localConfig = path3.join(rootDir, ".git", "config");
   let excludesFile = await readGitconfigExcludesFilePath(localConfig) ?? await readGitconfigExcludesFilePath(globalConfig2);
   if (!excludesFile) {
-    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir9(), ".config"), "git", "ignore");
+    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir10(), ".config"), "git", "ignore");
   }
   const candidates = [excludesFile, path3.join(rootDir, ".git", "info", "exclude")];
   const existing = [];
@@ -121213,9 +121128,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname13 = sp.dirname(file2);
+    const dirname14 = sp.dirname(file2);
     const basename4 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname13);
+    const parent = this.fsw._getWatchedDir(dirname14);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -121242,7 +121157,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname13, basename4);
+          this.fsw._remove(dirname14, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -122631,8 +122546,8 @@ function diffPathIndexes(previous, next4) {
 // src/infrastructure/services/workspace/workspace-sync-state.ts
 import { createHash as createHash7, randomUUID as randomUUID12 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
-import { homedir as homedir10 } from "node:os";
-import { join as join26 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join27 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -122646,10 +122561,10 @@ function buildPathIndex(entries2) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join26(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join27(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir(filePath) {
-  await fs11.mkdir(join26(filePath, ".."), { recursive: true, mode: 448 });
+  await fs11.mkdir(join27(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
@@ -122709,7 +122624,7 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join26(homedir10(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join27(homedir11(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
@@ -123087,12 +123002,12 @@ var init_durable_coalescing_state_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
-import { mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
-import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { mkdirSync as mkdirSync9 } from "node:fs";
+import { dirname as dirname15 } from "node:path";
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 function openDurableCoalescingStateStore(path8) {
-  mkdirSync8(dirname14(path8), { recursive: true });
-  const db = new DatabaseSync3(path8);
+  mkdirSync9(dirname15(path8), { recursive: true });
+  const db = new DatabaseSync4(path8);
   for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
     db.exec(sql);
   db.prepare("UPDATE coalescing_outbox_entries SET status='pending' WHERE status='in_flight'").run();
@@ -124080,7 +123995,7 @@ var init_file_write_request_priority = __esm(() => {
 
 // src/daemon/entry/files/file-write-fulfillment.ts
 import { access as access4, mkdir as mkdir10, rename as rename4, rm as rm4, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname16 } from "node:path";
 function isTerminalFileWriteError(errorMessage) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -124179,7 +124094,7 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir10(dirname15(absolutePath), { recursive: true });
+    await mkdir10(dirname16(absolutePath), { recursive: true });
     await writeFile10(absolutePath, content, { flag: "wx" });
     return;
   }
@@ -124257,7 +124172,7 @@ async function fulfillOneFileWriteRequest(session2, request2) {
         });
         return;
       }
-      await mkdir10(dirname15(targetResolved.absolutePath), { recursive: true });
+      await mkdir10(dirname16(targetResolved.absolutePath), { recursive: true });
       await rename4(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, claimed._id, claimed.revision, { status: "done" });
       const elapsed4 = Date.now() - startTime;
@@ -125332,16 +125247,16 @@ var init_workspace_list_subscription = __esm(() => {
 
 // src/daemon/entry/workspace-git-inbound-registry.ts
 function registerWorkspaceGitInboundHandler(h) {
-  handler5 = h;
+  handler4 = h;
 }
 function unregisterWorkspaceGitInboundHandler() {
-  handler5 = undefined;
+  handler4 = undefined;
 }
 async function dispatchWorkspaceGitInboundEvent(event) {
-  if (handler5)
-    await handler5(event);
+  if (handler4)
+    await handler4(event);
 }
-var handler5;
+var handler4;
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 var onDaemonShutdownEffect;
@@ -125359,6 +125274,19 @@ var init_on_daemon_shutdown = __esm(() => {
     const activeAgents = agentPm.listActive();
     if (activeAgents.length > 0) {
       console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s) locally...`);
+      yield* exports_Effect.promise(async () => {
+        try {
+          const tasksReleased = await session2.backend.mutation(api.daemon.taskStatus.releaseMachineTasks, {
+            sessionId: session2.sessionId,
+            machineId: session2.machineId
+          });
+          if (tasksReleased > 0) {
+            console.log(`[${formatTimestamp()}] Released ${tasksReleased} in-flight task(s) to pending`);
+          }
+        } catch (error51) {
+          console.log(`[${formatTimestamp()}] ⚠️  Failed to release in-flight tasks on shutdown: ${error51 instanceof Error ? error51.message : String(error51)}`);
+        }
+      });
       let totalStopped = 0;
       let totalFailed = 0;
       yield* exports_Effect.all(activeAgents.map(({ chatroomId, role }) => exports_Effect.promise(() => agentPm.stopAgent({ chatroomId, role, reason: "daemon.shutdown" })).pipe(exports_Effect.tap(() => exports_Effect.sync(() => {
@@ -125388,7 +125316,6 @@ function createDaemonRuntime(deps) {
   let workspaceListSubscriptionHandle = null;
   let logObserverSubscriptionHandle = null;
   let agenticQueryWorkerHandle = null;
-  let enhancerWorkerHandle = null;
   let taskInboxHandle = null;
   let agentConfigRegistryHandle = null;
   const activeSessions = new Map;
@@ -125429,7 +125356,6 @@ function createDaemonRuntime(deps) {
     taskInboxHandle?.stop();
     logObserverSubscriptionHandle?.stop();
     agenticQueryWorkerHandle?.stop();
-    enhancerWorkerHandle?.stop();
   };
   const shutdown = async () => {
     if (isShuttingDown)
@@ -125547,7 +125473,6 @@ function createDaemonRuntime(deps) {
       backend: session2.backend,
       convexUrl: session2.convexUrl
     }, activeSessions, harnesses);
-    enhancerWorkerHandle = startEnhancerSubscriptions(session2.sessionId, session2.machineId, session2.convexUrl, deps.wsClient, session2.backend, session2.agentServices, getActiveLogSink());
     console.log(`
 Listening for commands...`);
     console.log(`Press Ctrl+C to stop
@@ -125584,7 +125509,6 @@ var init_daemon_runtime = __esm(() => {
   init_start_subscriptions();
   init_command_dispatch();
   init_daemon_services();
-  init_start_subscriptions2();
   init_file_content_subscription();
   init_file_tree_subscription();
   init_file_write_subscription();
@@ -125592,7 +125516,6 @@ var init_daemon_runtime = __esm(() => {
   init_orphan_tracker();
   init_command_run_subscription();
   init_log_observer_sync();
-  init_init_daemon();
   init_task_inbox_runtime();
   init_git_subscription();
   init_api3();
@@ -125635,21 +125558,6 @@ function createCommandRouterDeps() {
 }
 var init_command_bridge = () => {};
 
-// src/daemon/domain/usecase/process-enhancer-job.ts
-async function processEnhancerJobInbound(deps, event) {
-  await deps.dispatchInbound(event);
-}
-
-// src/daemon/entry/bridge/enhancer-bridge.ts
-function createEnhancerRouterDeps() {
-  return {
-    deliverInbound: async (event) => {
-      await processEnhancerJobInbound({ dispatchInbound: dispatchEnhancerInboundEvent }, event);
-    }
-  };
-}
-var init_enhancer_bridge = () => {};
-
 // src/daemon/domain/usecase/fulfill-file-content-request.ts
 async function fulfillFileContentRequest(deps, event) {
   await deps.dispatchInbound(event);
@@ -125719,14 +125627,12 @@ function createDefaultEventRouterDeps() {
     command: createCommandRouterDeps(),
     workspaceGit: createWorkspaceGitRouterDeps(),
     file: createFileRouterDeps(),
-    agenticQuery: createAgenticQueryRouterDeps(),
-    enhancer: createEnhancerRouterDeps()
+    agenticQuery: createAgenticQueryRouterDeps()
   };
 }
 var init_default_router_deps = __esm(() => {
   init_agentic_query_bridge();
   init_command_bridge();
-  init_enhancer_bridge();
   init_file_bridge();
   init_workspace_git_bridge();
 });
@@ -126007,7 +125913,6 @@ async function executeChatroomStopCommand(args2) {
     args2.apm.markStopIntent(args2.chatroomId, args2.role, "user.stop", undefined, args2.workingDir);
   else if (!args2.workingDir) {
     args2.apm.markChatroomStopIntent(args2.chatroomId, "user.stop");
-    await abortEnhancerSpawnsForChatroom(args2.chatroomId);
   }
   const confirmedDeps = args2.apm.getConfirmedStopAdapterDeps();
   const targets = await args2.apm.discoverStopTargets(args2.chatroomId);
@@ -126040,15 +125945,14 @@ async function executeChatroomStopCommand(args2) {
 }
 var init_execute_chatroom_stop_command = __esm(() => {
   init_reliability();
-  init_enhancer_spawn_registry();
   init_agent_process_service2();
 });
 
 // src/daemon/entry/persistence-path.ts
-import { homedir as homedir11 } from "node:os";
-import { join as join27 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join28 } from "node:path";
 function resolvePersistenceDbPath(machineId) {
-  return join27(homedir11(), ".chatroom", "daemon", machineId, "events.sqlite");
+  return join28(homedir12(), ".chatroom", "daemon", machineId, "events.sqlite");
 }
 var init_persistence_path = () => {};
 
@@ -126066,13 +125970,6 @@ async function handleCommandInbound(deps, event) {
   }
 }
 
-// src/daemon/domain/usecase/handle-enhancer-inbound.ts
-async function handleEnhancerInbound(deps, event) {
-  if (deps.deliverInbound) {
-    await deps.deliverInbound(event);
-  }
-}
-
 // src/daemon/domain/usecase/handle-file-inbound.ts
 async function handleFileInbound(deps, event) {
   if (deps.deliverInbound) {
@@ -126108,9 +126005,6 @@ async function routeInboundEvent(deps, event) {
     case "agentic-query.prompt":
       await handleAgenticQueryInbound(deps.agenticQuery, event);
       break;
-    case "enhancer.job-assigned":
-      await handleEnhancerInbound(deps.enhancer, event);
-      break;
     default:
   }
 }
@@ -126218,80 +126112,6 @@ var init_command_run = __esm(() => {
   init_api3();
 });
 
-// src/daemon/infrastructure/convex/subscribers/enhancer-job.ts
-function startEnhancerJobSubscriber2(deps, onEvent) {
-  const seen = new Set;
-  const watchers = new Map;
-  let stopped = false;
-  let refreshInFlight = false;
-  const onPendingJobs = (jobs) => {
-    if (!jobs?.length)
-      return;
-    for (const job of jobs) {
-      if (job == null || typeof job !== "object" || !("jobId" in job))
-        continue;
-      if (seen.has(job.jobId))
-        continue;
-      seen.add(job.jobId);
-      onEvent({ type: "enhancer.job-assigned", jobId: job.jobId });
-    }
-  };
-  const onError3 = (err) => {
-    console.warn(`[daemon] enhancer-job subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  };
-  const watchChatroom = (chatroomId) => {
-    if (watchers.has(chatroomId) || stopped)
-      return;
-    const unsub = deps.wsClient.onUpdate(api.daemon.enhancer.index.pendingForChatroom, {
-      sessionId: deps.sessionId,
-      machineId: deps.machineId,
-      chatroomId
-    }, onPendingJobs, onError3);
-    watchers.set(chatroomId, unsub);
-  };
-  const refreshChatrooms = async () => {
-    if (refreshInFlight)
-      return;
-    refreshInFlight = true;
-    try {
-      const workspaces = await deps.wsClient.query(api.workspaces.listWorkspacesForMachine, {
-        sessionId: deps.sessionId,
-        machineId: deps.machineId
-      });
-      if (stopped)
-        return;
-      const roomIds = [
-        ...new Set((workspaces ?? []).map((ws) => ws.chatroomId))
-      ];
-      for (const [roomId, unsub] of watchers) {
-        if (!roomIds.includes(roomId)) {
-          unsub();
-          watchers.delete(roomId);
-        }
-      }
-      for (const roomId of roomIds)
-        watchChatroom(roomId);
-    } catch (error51) {
-      console.warn(`[daemon] enhancer-job room refresh failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    } finally {
-      refreshInFlight = false;
-    }
-  };
-  refreshChatrooms();
-  return {
-    async stop() {
-      stopped = true;
-      for (const unsub of watchers.values())
-        unsub();
-      watchers.clear();
-    },
-    refreshChatrooms
-  };
-}
-var init_enhancer_job = __esm(() => {
-  init_api3();
-});
-
 // src/daemon/infrastructure/convex/subscribers/pending-file-request-dedup.ts
 function pendingConvexId(req) {
   if (req._id == null)
@@ -126608,7 +126428,6 @@ function startAllSubscribers(deps) {
   const onEvent = (event) => {
     routeInboundEvent(deps.router, event);
   };
-  const enhancerJob = startEnhancerJobSubscriber2(deps, onEvent);
   const gitRequest = startGitRequestSubscriber(deps, onEvent);
   const machineCommands = startMachineCommandInboxSubscriber(deps, async (claimed) => {
     if (claimed.type === "agent.stop") {
@@ -126639,8 +126458,7 @@ function startAllSubscribers(deps) {
         fileContent.stop(),
         fileWrite.stop(),
         agenticQuerySession.stop(),
-        agenticQueryPrompt.stop(),
-        enhancerJob.stop()
+        agenticQueryPrompt.stop()
       ]);
     }
   };
@@ -126650,7 +126468,6 @@ var init_subscriber_registry = __esm(() => {
   init_agentic_query_prompt();
   init_agentic_query_session();
   init_command_run();
-  init_enhancer_job();
   init_file_content_request();
   init_file_tree_release_request();
   init_file_tree_request();
@@ -126699,12 +126516,12 @@ var init_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/persistence/open-database.ts
-import { mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
-import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
+import { mkdirSync as mkdirSync10 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
+import { DatabaseSync as DatabaseSync5 } from "node:sqlite";
 function openDatabase(dbPath) {
-  mkdirSync9(dirname16(dbPath), { recursive: true });
-  const db = new DatabaseSync4(dbPath);
+  mkdirSync10(dirname17(dbPath), { recursive: true });
+  const db = new DatabaseSync5(dbPath);
   for (const sql of MIGRATIONS2) {
     db.exec(sql);
   }
@@ -134199,19 +134016,19 @@ function routeRequest(req, res, deps) {
 
 // src/daemon/local-web/server/serve-static.ts
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname17, join as join28 } from "node:path";
+import { dirname as dirname18, join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function clientDistCandidates(here) {
   return [
-    join28(here, "client/build"),
-    join28(here, "../client/build"),
-    join28(here, "../src/daemon/local-web/client/build")
+    join29(here, "client/build"),
+    join29(here, "../client/build"),
+    join29(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir(here = dirname17(fileURLToPath7(import.meta.url))) {
+function resolveClientDistDir(here = dirname18(fileURLToPath7(import.meta.url))) {
   const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
-    if (existsSync10(join28(dir, "index.html")))
+    if (existsSync10(join29(dir, "index.html")))
       return dir;
   }
   return candidates[0];
@@ -134224,7 +134041,7 @@ function tryServeStatic(req, res, distDir) {
     return false;
   }
   const safePath = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join28(distDir, safePath);
+  const filePath = join29(distDir, safePath);
   if (!filePath.startsWith(distDir)) {
     res.writeHead(403);
     res.end();
@@ -134241,7 +134058,7 @@ function tryServeStatic(req, res, distDir) {
     }
     return true;
   }
-  const indexPath = join28(distDir, "index.html");
+  const indexPath = join29(distDir, "index.html");
   if (existsSync10(indexPath)) {
     res.writeHead(200, { "Content-Type": "text/html" });
     if (req.method === "HEAD") {
@@ -134290,6 +134107,14 @@ function normalizeError(err) {
       details: err.flatten()
     };
   }
+  if (err instanceof ConvexError) {
+    const data = err.data;
+    return {
+      code: data.code ?? "internal_error",
+      message: data.message ?? err.message,
+      details: err.data
+    };
+  }
   if (err instanceof Error) {
     const code2 = "code" in err && typeof err.code === "string" ? err.code : "internal_error";
     if (code2 === "not_found" || code2 === "validation_error" || code2 === "unauthorized") {
@@ -134300,6 +134125,7 @@ function normalizeError(err) {
   return { code: "internal_error", message: "Unknown error" };
 }
 var init_normalize_error = __esm(() => {
+  init_values();
   init_zod();
 });
 
@@ -134430,6 +134256,16 @@ function extractAck(args2) {
   }
   return { payload: args2[0], ack: undefined };
 }
+async function resolveDebugStatePayload(deps, payload) {
+  if (!deps.debugState)
+    throw new Error("daemon debug state is not configured");
+  const { chatroomId } = debugStateInputSchema.parse(payload ?? {});
+  const data = await deps.debugState(chatroomId);
+  if (data && typeof data === "object" && deps.cliGateway) {
+    data.cliGateway = deps.cliGateway.debugState();
+  }
+  return data;
+}
 function registerSocketHandlers(io2, deps) {
   const logHistory = deps.logRepo ? createLogHistoryUseCase({ reader: deps.logRepo }) : undefined;
   const eventStreamHistory = deps.logRepo ? createEventStreamHistoryUseCase({ reader: deps.logRepo }) : undefined;
@@ -134449,13 +134285,22 @@ function registerSocketHandlers(io2, deps) {
         callAck(ack, { ok: false, error: normalizeError(err) });
       }
     });
+    socket.on("cli.handoff", async (...args2) => {
+      const { payload, ack } = extractAck(args2);
+      try {
+        if (!deps.cliGateway)
+          throw new Error("CLI gateway is not configured");
+        const data = await deps.cliGateway.handoff(payload);
+        callAck(ack, { ok: true, data });
+      } catch (err) {
+        callAck(ack, { ok: false, error: normalizeError(err) });
+      }
+    });
     socket.on("daemon.debug.state", async (...args2) => {
       const { payload, ack } = extractAck(args2);
       try {
-        if (!deps.debugState)
-          throw new Error("daemon debug state is not configured");
-        const { chatroomId } = debugStateInputSchema.parse(payload ?? {});
-        callAck(ack, { ok: true, data: await deps.debugState(chatroomId) });
+        const data = await resolveDebugStatePayload(deps, payload);
+        callAck(ack, { ok: true, data });
       } catch (err) {
         callAck(ack, { ok: false, error: normalizeError(err) });
       }
@@ -134639,7 +134484,8 @@ async function startLocalWebServer(config4, deps = {}) {
     eventStreamHub: deps.eventStreamHub,
     backend: deps.backend,
     sessionId: deps.sessionId,
-    debugState: deps.debugState
+    debugState: deps.debugState,
+    cliGateway: deps.cliGateway
   });
   return {
     port: boundPort,
@@ -134695,6 +134541,80 @@ function createLogStreamHub() {
   };
 }
 
+// src/daemon/services/cli-gateway-service/index.ts
+function createCliGatewayService(deps) {
+  const logs2 = [];
+  const writeLog = (message) => {
+    logs2.push({ timestamp: Date.now(), message });
+    if (logs2.length > 100)
+      logs2.shift();
+    (deps.log ?? console.log)(`[CliGateway:${message}]`);
+  };
+  return {
+    handoff: async (args2) => {
+      writeLog(`request handoff chatroom=${args2.chatroomId} role=${args2.senderRole}`);
+      const taskIdsBeforeCommit = getActiveTaskIdsForRole(deps, args2);
+      const result = await commitHandoffMutation(deps, args2, writeLog);
+      writeLog(`backend result success=${result.success}`);
+      if (result.success) {
+        await syncTaskServiceAfterHandoff(deps, args2, result, taskIdsBeforeCommit, writeLog);
+      }
+      return result;
+    },
+    debugState: () => ({ port: deps.port, logs: [...logs2] })
+  };
+}
+function getActiveTaskIdsForRole(deps, args2) {
+  return deps.taskService.listTasksForRole?.(args2.chatroomId, args2.senderRole).filter((task) => task.status === "acknowledged" || task.status === "in_progress").map((task) => task.taskId) ?? [];
+}
+async function commitHandoffMutation(deps, args2, writeLog) {
+  try {
+    return await deps.backend.mutation(api.messages.handoff, args2);
+  } catch (error51) {
+    writeLog(`backend failure=${error51 instanceof Error ? error51.message : String(error51)}`);
+    throw error51;
+  }
+}
+async function syncTaskServiceAfterHandoff(deps, args2, result, taskIdsBeforeCommit, writeLog) {
+  try {
+    const nextTask = await adoptNextHandoffTask(deps, args2, result);
+    await deps.taskService.recordHandoffOutcome({
+      chatroomId: args2.chatroomId,
+      role: args2.senderRole,
+      targetRole: args2.targetRole,
+      nextTask,
+      taskIds: taskIdsBeforeCommit
+    });
+    writeLog(`task-service updated chatroom=${args2.chatroomId} role=${args2.senderRole}` + (nextTask ? ` adopted=${nextTask.taskId}` : ""));
+  } catch (error51) {
+    writeLog(`post-commit sync failure chatroom=${args2.chatroomId} error=${error51 instanceof Error ? error51.message : String(error51)}`);
+    await recordFallbackHandoffOutcome(deps, args2, writeLog);
+  }
+}
+async function adoptNextHandoffTask(deps, args2, result) {
+  if (!result.newTaskId || args2.targetRole.toLowerCase() === "user")
+    return;
+  return await deps.taskService.loadAssignedTaskForAction({
+    chatroomId: args2.chatroomId,
+    role: args2.targetRole,
+    taskId: result.newTaskId
+  }) ?? undefined;
+}
+async function recordFallbackHandoffOutcome(deps, args2, writeLog) {
+  try {
+    await deps.taskService.recordHandoffOutcome({
+      chatroomId: args2.chatroomId,
+      role: args2.senderRole,
+      targetRole: args2.targetRole
+    });
+  } catch (cleanupError) {
+    writeLog(`post-commit cleanup failure chatroom=${args2.chatroomId} error=${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+  }
+}
+var init_cli_gateway_service = __esm(() => {
+  init_api3();
+});
+
 // src/daemon/entry/start-daemon.ts
 async function startDaemon() {
   let resolveBoundPort;
@@ -134729,6 +134649,11 @@ async function startDaemon() {
     logEvent: init2.logEvent
   });
   const localWebPort = resolveLocalWebPort();
+  const cliGateway = createCliGatewayService({
+    backend: init2.backend,
+    port: localWebPort,
+    taskService: init2.taskService
+  });
   const debugState = async (chatroomId) => {
     const persisted = await loadDaemonState(init2.machineId);
     const persistedAgents = Object.fromEntries(Object.entries(persisted?.agents ?? {}).filter(([key]) => key.startsWith(`${chatroomId}/`)));
@@ -134786,7 +134711,8 @@ async function startDaemon() {
     eventStreamHub,
     backend: init2.backend,
     sessionId: init2.sessionId,
-    debugState
+    debugState,
+    cliGateway
   });
   resolveBoundPort(localWeb.port);
   const subscribers = startAllSubscribers({
@@ -134847,6 +134773,7 @@ var init_start_daemon = __esm(() => {
   init_log_repository();
   init_socket3();
   init_create_local_web_server();
+  init_cli_gateway_service();
 });
 
 // src/commands/machine/daemon-start/index.ts
@@ -136103,4 +136030,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=F7E2E413529D2D3564756E2164756E21
+//# debugId=CB5CA35B81D3EFBC64756E2164756E21