chatroom-cli 1.117.6 → 1.119.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();
@@ -27764,6 +27792,100 @@ var init_base_cli_agent_service = __esm(() => {
   retrySchedule = exports_Schedule.exponential(exports_Duration.millis(DETECTION_RETRY_POLICY.initialDelayMs), DETECTION_RETRY_POLICY.backoffFactor).pipe(exports_Schedule.either(exports_Schedule.spaced(exports_Duration.millis(DETECTION_RETRY_POLICY.maxDelayMs))), exports_Schedule.compose(exports_Schedule.recurs(DETECTION_RETRY_POLICY.maxAttempts - 1)));
 });
 
+// ../../services/backend/src/domain/entities/_shared/v-literals-of.ts
+var toLiteralValidators = (values3) => values3.map((v_) => v.literal(v_));
+var init_v_literals_of = __esm(() => {
+  init_values();
+});
+
+// ../../services/backend/src/domain/entities/agent.ts
+var AGENT_HARNESSES, AgentHarnessEnum, agentHarnessValidator, AGENT_TYPES, AgentTypeEnum, agentTypeValidator, MACHINE_COMMAND_TYPES, MachineCommandTypeEnum, machineCommandTypeValidator, MACHINE_COMMAND_STATUSES, MachineCommandStatusEnum, machineCommandStatusValidator, AgentStartReasonCode, AGENT_START_REASONS, DaemonStartReasonCode, agentStartReasonValidator, USER_EXPLICIT_START_REASONS, EXPLICIT_DAEMON_START_REASONS, isExplicitDaemonStart = (reason) => EXPLICIT_DAEMON_START_REASONS.includes(reason), AGENT_STOP_REASONS, agentPostStopDesiredStateValidator, AgentStopReasonEnum, MODEL_SOURCES, ModelSourceEnum, modelSourceValidator;
+var init_agent = __esm(() => {
+  init_values();
+  init_v_literals_of();
+  AGENT_HARNESSES = [
+    "opencode",
+    "opencode-sdk",
+    "pi",
+    "pi-sdk",
+    "cursor",
+    "cursor-sdk",
+    "claude",
+    "claude-sdk",
+    "codex-sdk",
+    "copilot",
+    "commandcode"
+  ];
+  AgentHarnessEnum = Object.fromEntries(AGENT_HARNESSES.map((h) => [h, h]));
+  agentHarnessValidator = v.union(...toLiteralValidators(AGENT_HARNESSES));
+  AGENT_TYPES = ["remote", "custom"];
+  AgentTypeEnum = Object.fromEntries(AGENT_TYPES.map((t) => [t, t]));
+  agentTypeValidator = v.union(...toLiteralValidators(AGENT_TYPES));
+  MACHINE_COMMAND_TYPES = ["start-agent", "restart-agent", "ping", "status"];
+  MachineCommandTypeEnum = Object.fromEntries(MACHINE_COMMAND_TYPES.map((c) => [c, c]));
+  machineCommandTypeValidator = v.union(...toLiteralValidators(MACHINE_COMMAND_TYPES));
+  MACHINE_COMMAND_STATUSES = ["pending", "completed", "failed"];
+  MachineCommandStatusEnum = Object.fromEntries(MACHINE_COMMAND_STATUSES.map((s) => [s, s]));
+  machineCommandStatusValidator = v.union(...toLiteralValidators(MACHINE_COMMAND_STATUSES));
+  AgentStartReasonCode = {
+    USER_START: "user.start",
+    USER_RESTART: "user.restart",
+    USER_MANUAL_SPAWN: "user.manual_spawn",
+    PLATFORM_TASK_MONITOR_NUDGE: "platform.task_monitor_nudge",
+    PLATFORM_TASK_START_IN_NEW_SESSION: "platform.task_start_in_new_session",
+    PLATFORM_PENDING_TASK_WAKE: "platform.pending_task_wake",
+    PLATFORM_AUTO_RESTART_ON_NEW_CONTEXT: "platform.auto_restart_on_new_context",
+    PLATFORM_TEAM_SWITCH: "platform.team_switch",
+    TEST: "test"
+  };
+  AGENT_START_REASONS = [
+    AgentStartReasonCode.USER_START,
+    AgentStartReasonCode.USER_RESTART,
+    AgentStartReasonCode.USER_MANUAL_SPAWN,
+    AgentStartReasonCode.PLATFORM_TASK_MONITOR_NUDGE,
+    AgentStartReasonCode.PLATFORM_TASK_START_IN_NEW_SESSION,
+    AgentStartReasonCode.PLATFORM_PENDING_TASK_WAKE,
+    AgentStartReasonCode.PLATFORM_AUTO_RESTART_ON_NEW_CONTEXT,
+    AgentStartReasonCode.PLATFORM_TEAM_SWITCH,
+    AgentStartReasonCode.TEST
+  ];
+  DaemonStartReasonCode = {
+    RESPAWN: "daemon.respawn"
+  };
+  agentStartReasonValidator = v.union(...toLiteralValidators(AGENT_START_REASONS));
+  USER_EXPLICIT_START_REASONS = [
+    AgentStartReasonCode.USER_START,
+    AgentStartReasonCode.USER_RESTART
+  ];
+  EXPLICIT_DAEMON_START_REASONS = [
+    ...USER_EXPLICIT_START_REASONS,
+    AgentStartReasonCode.USER_MANUAL_SPAWN,
+    AgentStartReasonCode.PLATFORM_TASK_MONITOR_NUDGE,
+    AgentStartReasonCode.PLATFORM_PENDING_TASK_WAKE,
+    AgentStartReasonCode.PLATFORM_TASK_START_IN_NEW_SESSION,
+    DaemonStartReasonCode.RESPAWN
+  ];
+  AGENT_STOP_REASONS = [
+    "user.stop",
+    "user.restart",
+    "platform.dedup",
+    "platform.team_switch",
+    "platform.task_monitor_nudge",
+    "platform.task_start_in_new_session",
+    "daemon.respawn",
+    "daemon.shutdown",
+    "daemon.stop_timeout",
+    "platform.ephemeral_task_complete",
+    "platform.task_cancelled",
+    "test"
+  ];
+  agentPostStopDesiredStateValidator = v.union(v.literal("running"), v.literal("stopped"));
+  AgentStopReasonEnum = Object.fromEntries(AGENT_STOP_REASONS.map((r) => [r, r]));
+  MODEL_SOURCES = ["team_config", "none"];
+  ModelSourceEnum = Object.fromEntries(MODEL_SOURCES.map((s) => [s, s]));
+  modelSourceValidator = v.union(...toLiteralValidators(MODEL_SOURCES));
+});
+
 // ../../services/backend/src/domain/entities/harness/claude-sdk.config.ts
 var claudeSdkCapabilities;
 var init_claude_sdk_config = __esm(() => {
@@ -28230,7 +28352,7 @@ function createAgentProcessManagerService(deps) {
             await awaitWithinDeadline(deps.execution.stop({
               chatroomId: input.chatroomId,
               role: input.role,
-              reason: "daemon.respawn",
+              reason: DaemonStartReasonCode.RESPAWN,
               pid: slot.pid,
               workingDir: input.workingDir
             }), remaining, input.signal);
@@ -28334,11 +28456,13 @@ 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;
 var init_agent_process_manager_service = __esm(() => {
+  init_agent();
   init_types();
   init_check_agent_slot();
 });
@@ -28743,86 +28867,6 @@ var init_native_turn_phase = __esm(() => {
   init_agent_slot();
 });
 
-// ../../services/backend/src/domain/entities/_shared/v-literals-of.ts
-var toLiteralValidators = (values3) => values3.map((v_) => v.literal(v_));
-var init_v_literals_of = __esm(() => {
-  init_values();
-});
-
-// ../../services/backend/src/domain/entities/agent.ts
-var AGENT_HARNESSES, AgentHarnessEnum, agentHarnessValidator, AGENT_TYPES, AgentTypeEnum, agentTypeValidator, MACHINE_COMMAND_TYPES, MachineCommandTypeEnum, machineCommandTypeValidator, MACHINE_COMMAND_STATUSES, MachineCommandStatusEnum, machineCommandStatusValidator, AGENT_START_REASONS, AgentStartReasonEnum, agentStartReasonValidator, USER_EXPLICIT_START_REASONS, EXPLICIT_DAEMON_START_REASONS, isExplicitDaemonStart = (reason) => EXPLICIT_DAEMON_START_REASONS.includes(reason), AGENT_STOP_REASONS, agentPostStopDesiredStateValidator, AgentStopReasonEnum, MODEL_SOURCES, ModelSourceEnum, modelSourceValidator;
-var init_agent = __esm(() => {
-  init_values();
-  init_v_literals_of();
-  AGENT_HARNESSES = [
-    "opencode",
-    "opencode-sdk",
-    "pi",
-    "pi-sdk",
-    "cursor",
-    "cursor-sdk",
-    "claude",
-    "claude-sdk",
-    "codex-sdk",
-    "copilot",
-    "commandcode"
-  ];
-  AgentHarnessEnum = Object.fromEntries(AGENT_HARNESSES.map((h) => [h, h]));
-  agentHarnessValidator = v.union(...toLiteralValidators(AGENT_HARNESSES));
-  AGENT_TYPES = ["remote", "custom"];
-  AgentTypeEnum = Object.fromEntries(AGENT_TYPES.map((t) => [t, t]));
-  agentTypeValidator = v.union(...toLiteralValidators(AGENT_TYPES));
-  MACHINE_COMMAND_TYPES = ["start-agent", "restart-agent", "ping", "status"];
-  MachineCommandTypeEnum = Object.fromEntries(MACHINE_COMMAND_TYPES.map((c) => [c, c]));
-  machineCommandTypeValidator = v.union(...toLiteralValidators(MACHINE_COMMAND_TYPES));
-  MACHINE_COMMAND_STATUSES = ["pending", "completed", "failed"];
-  MachineCommandStatusEnum = Object.fromEntries(MACHINE_COMMAND_STATUSES.map((s) => [s, s]));
-  machineCommandStatusValidator = v.union(...toLiteralValidators(MACHINE_COMMAND_STATUSES));
-  AGENT_START_REASONS = [
-    "user.start",
-    "user.restart",
-    "user.manual_spawn",
-    "platform.task_monitor_nudge",
-    "platform.task_start_in_new_session",
-    "platform.pending_task_wake",
-    "platform.auto_restart_on_new_context",
-    "platform.team_switch",
-    "test"
-  ];
-  AgentStartReasonEnum = Object.fromEntries(AGENT_START_REASONS.map((r) => [r, r]));
-  agentStartReasonValidator = v.union(...toLiteralValidators(AGENT_START_REASONS));
-  USER_EXPLICIT_START_REASONS = [
-    AgentStartReasonEnum["user.start"],
-    AgentStartReasonEnum["user.restart"]
-  ];
-  EXPLICIT_DAEMON_START_REASONS = [
-    ...USER_EXPLICIT_START_REASONS,
-    AgentStartReasonEnum["user.manual_spawn"],
-    AgentStartReasonEnum["platform.task_monitor_nudge"],
-    AgentStartReasonEnum["platform.task_start_in_new_session"],
-    "daemon.respawn"
-  ];
-  AGENT_STOP_REASONS = [
-    "user.stop",
-    "user.restart",
-    "platform.dedup",
-    "platform.team_switch",
-    "platform.task_monitor_nudge",
-    "platform.task_start_in_new_session",
-    "daemon.respawn",
-    "daemon.shutdown",
-    "daemon.stop_timeout",
-    "platform.ephemeral_task_complete",
-    "platform.task_cancelled",
-    "test"
-  ];
-  agentPostStopDesiredStateValidator = v.union(v.literal("running"), v.literal("stopped"));
-  AgentStopReasonEnum = Object.fromEntries(AGENT_STOP_REASONS.map((r) => [r, r]));
-  MODEL_SOURCES = ["team_config", "none"];
-  ModelSourceEnum = Object.fromEntries(MODEL_SOURCES.map((s) => [s, s]));
-  modelSourceValidator = v.union(...toLiteralValidators(MODEL_SOURCES));
-});
-
 // src/daemon/services/agent-process-service/infrastructure/adapters/orphan-process-tracker.ts
 import { createHash } from "node:crypto";
 import {
@@ -43645,7 +43689,7 @@ var init_agent_lifecycle_fact_schema = __esm(() => {
       ...agent,
       kind: exports_external.literal("status"),
       status: exports_external.enum(["offline", "starting", "waiting", "working", "stopping", "error"]),
-      errorSource: exports_external.enum(["configuration", "runtime", "task", "enhancer", "stop"]).optional(),
+      errorSource: exports_external.enum(["configuration", "runtime", "task", "stop"]).optional(),
       errorCode: exports_external.string().optional(),
       errorMessage: exports_external.string().optional()
     }),
@@ -44651,29 +44695,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 +44723,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 +44751,7 @@ class AgentProcessManager {
   exitRetryQueue = [];
   exitRetryTimer = null;
   agentTurnEndedHandlers = new Set;
+  agentTurnProgressHandlers = new Set;
   agentTurnEndedSequence = 0;
   agentStartedHandlers = new Set;
   agentSessionLostHandlers = new Set;
@@ -44800,6 +44839,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;
@@ -45373,7 +45425,7 @@ class AgentProcessManager {
       slot.state = AGENT_SLOT_STATE.STOPPING;
       const stopGeneration = this.bumpStopGeneration(slot);
       slot.stoppingSince = this.deps.clock.now();
-      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn", workingDir }, stopGeneration);
+      await this.doStop(key, slot, pid, { chatroomId, role, reason: DaemonStartReasonCode.RESPAWN, workingDir }, stopGeneration);
     }
   }
   async killPersistedProcessIfAlive(chatroomId, role, workingDir) {
@@ -45719,13 +45771,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 +45793,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)}`);
         });
       }
@@ -45763,6 +45814,9 @@ class AgentProcessManager {
   }
   async doEnsureRunning(key, slot, opts) {
     slot.state = AGENT_SLOT_STATE.SPAWNING;
+    const rateLimit = this.checkRateLimitGate(opts, slot);
+    if (rateLimit)
+      return rateLimit;
     const authorization = await this.deps.backend.mutation(api.machines.authorizeAgentStart, {
       sessionId: this.deps.sessionId,
       machineId: this.deps.machineId,
@@ -45777,9 +45831,6 @@ class AgentProcessManager {
     const wantResume = opts.wantResume;
     console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${wantResume} reason=${opts.reason}`);
     try {
-      const rateLimit = this.checkRateLimitGate(opts, slot);
-      if (rateLimit)
-        return rateLimit;
       const workingDir = await this.validateWorkingDirGate(opts, slot);
       if (workingDir)
         return workingDir;
@@ -46193,7 +46244,7 @@ async function ensureColdSessionBeforeNativeInject(task, deps) {
         agentHarness,
         model,
         workingDir,
-        reason: AgentStartReasonEnum["platform.task_start_in_new_session"],
+        reason: AgentStartReasonCode.PLATFORM_TASK_START_IN_NEW_SESSION,
         wantResume: false
       }, context5.signal);
       return waitForHarnessSessionId(deps.agentMgr, chatroomId, role, context5.signal);
@@ -46941,6 +46992,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 +47040,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 +47050,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 +47177,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 +47291,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 +47331,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 +47368,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 +47419,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 +47451,12 @@ function createTaskService(deps) {
       machineId: deps.machineId,
       taskId,
       ...expectedReason ? { expectedReason } : {}
-    })
+    }),
+    recordUncoveredTurnEnd,
+    isRedeliveryExhausted,
+    clearRedeliveryTracking: ({ chatroomId, role }) => {
+      clearRoleRedeliveryTracking(chatroomId, role);
+    }
   };
   return service4;
 }
@@ -47247,6 +47469,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 +47558,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 +47676,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 +47748,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();
 });
@@ -47485,7 +47769,7 @@ async function processTasksUpdate(taskService, configurationService, pass, isTas
         agentHarness: agentConfig.agentHarness,
         model: agentConfig.model ?? "",
         workingDir: agentConfig.workingDir,
-        reason: AgentStartReasonEnum["platform.pending_task_wake"],
+        reason: AgentStartReasonCode.PLATFORM_PENDING_TASK_WAKE,
         wantResume: false,
         taskId: task.taskId
       };
@@ -47567,6 +47851,7 @@ class AgentWorkManager {
   unsubscribeAgentTurnEnded;
   unsubscribeAgentStarted;
   unsubscribeAgentSessionLost;
+  unsubscribeAgentTurnProgress;
   reconcileStates = new Map;
   unsubscribeTaskService;
   nativeTaskDeliveryQueue;
@@ -47599,16 +47884,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 +47928,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 +47973,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 +47993,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 +48030,7 @@ class AgentWorkManager {
     this.unsubscribeAgentTurnEnded();
     this.unsubscribeAgentStarted();
     this.unsubscribeAgentSessionLost();
+    this.unsubscribeAgentTurnProgress();
     this.unsubscribeTaskService?.();
     this.unsubscribeTaskService = undefined;
     this.nativeTaskDeliveryQueue.stop();
@@ -47809,6 +48144,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 +48184,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 +51193,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 +51206,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 +51221,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 +52122,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 +52135,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 +52150,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 +52176,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 +53112,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 +53125,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 +53192,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 +53236,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 +53252,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 +55363,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 +55382,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 +55932,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 +55945,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 +55960,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 +64117,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 +64357,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 +64551,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 +64563,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 +77573,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 +99226,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 +99555,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 +99613,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 +99723,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`;
@@ -106625,15 +106986,15 @@ var init_team_presets = __esm(() => {
     duo: {
       structureId: TEAM_STRUCTURE_IDS.duo,
       name: "Duo",
-      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral enhancer",
-      roles: ["planner", "enhancer", "builder"],
+      description: "A planner and builder working as a pair, planner as coordinator, with optional ephemeral architect and optional ephemeral uiux-engineer roles",
+      roles: ["planner", "architect", "uiux-engineer", "builder"],
       entryPoint: "planner"
     },
     solo: {
       structureId: TEAM_STRUCTURE_IDS.solo,
       name: "Solo",
-      description: "A single agent working independently, with optional ephemeral enhancer",
-      roles: ["solo", "enhancer"],
+      description: "A single agent working independently, with optional ephemeral architect and optional ephemeral uiux-engineer roles",
+      roles: ["solo", "architect", "uiux-engineer"],
       entryPoint: "solo"
     }
   };
@@ -106829,6 +107190,22 @@ var init_agent2 = __esm(() => {
   init_storage2();
 });
 
+// ../../services/backend/prompts/cli/handoff/command.ts
+function handoffCommand(params) {
+  const prefix = params.cliEnvPrefix || "";
+  const chatroomId = params.chatroomId || "<chatroom-id>";
+  const role = params.role || "<role>";
+  const nextRole = params.nextRole || "<target>";
+  const placeholder = params.messagePlaceholder ?? "[Your message here]";
+  const commandPrefix = `${prefix}chatroom handoff --chatroom-id="${chatroomId}" --role="${role}" --next-role="${nextRole}"`;
+  return formatStdinHeredocCommand(commandPrefix, HANDOFF_STDIN_DELIMITER, placeholder, {
+    messageMarker: HANDOFF_MESSAGE_MARKER
+  });
+}
+var init_command2 = __esm(() => {
+  init_stdin_heredoc();
+});
+
 // ../../services/backend/prompts/native/handoff-visibility.ts
 function recipientLabel(toRole) {
   return toRole.toLowerCase() === "user" ? "The user" : `The \`${toRole}\` agent`;
@@ -106852,6 +107229,285 @@ Put your **complete** deliverable in the handoff message — not in session text
 ---`;
 }
 
+// ../../services/backend/prompts/utils/file-reference-guidance.ts
+function getFileReferenceGuidanceComment() {
+  return `<!-- File references (clickable in workspace UI): use repo-relative paths with a file extension — e.g. \`apps/webapp/src/modules/chatroom/foo.ts\` or [apps/webapp/src/foo.ts](apps/webapp/src/foo.ts). Avoid absolute paths, file:// prefixes, and paths without / or extension. -->`;
+}
+function getFileReferenceProofOfCompletionExample() {
+  return `${getFileReferenceGuidanceComment()}
+- \`apps/webapp/src/path/to/file.ts\` — <what changed and why>`;
+}
+
+// ../../services/backend/prompts/teams/architect-handoff-templates.ts
+function normalizeEntryPointRole(entryPointRole) {
+  return entryPointRole.trim().toLowerCase() || "planner";
+}
+function getArchitectFocus() {
+  return "module boundaries, APIs, schemas, indexes and queries, invariants, failure and recovery handling, tests, and implementation sequence";
+}
+function getArchitectRequirements() {
+  return `
+- Cite repository evidence for domain model/entity ownership, lifecycle, invariants, identifiers, and relationships.
+- Define service and module boundaries, public and internal APIs, function signatures, and ownership of side effects.
+- Analyze concurrency and races: concurrent writers, idempotency, ordering and monotonicity, retries, transactions, and failure/recovery behavior.
+- Design read patterns first: primary read paths, indexes, projections/read models, query shapes, scan and transaction limits, and invalidation/subscription scope.
+- Account for Convex reactivity and bandwidth: query invalidation patterns, avoiding unnecessary reactive fanout, and separating high-frequency heartbeat/liveness/status fields from low-frequency identity/configuration fields.
+- Specify concrete schema, query, and mutation changes; migration/backfill sequence; tests; and verification order.`;
+}
+function getEntryPointToArchitectHandoffTemplate(entryPointRole) {
+  const entryPoint = normalizeEntryPointRole(entryPointRole);
+  return `${getHandoffRecipientVisibilityCallout("architect")}
+
+## Handoff Template (${entryPoint} → architect)
+
+The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the Architect needs to design within the existing repository and team scope.
+
+Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getArchitectFocus()}.
+
+After completing the design, hand it back to \`${entryPoint}\` with the normal handoff command. Stop after the successful handoff; do not implement the design or delegate further work.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "architect",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getArchitectToEntryPointHandoffTemplate(entryPointRole) {
+  return renderArchitectToEntryPointHandoffTemplate(normalizeEntryPointRole(entryPointRole));
+}
+function getGenericArchitectToEntryPointHandoffTemplate() {
+  return renderArchitectToEntryPointHandoffTemplate("<entry-point-role>", true);
+}
+function renderArchitectToEntryPointHandoffTemplate(entryPoint, generic = false) {
+  const sharedContractsHeading = !generic && entryPoint === "planner" ? "## Shared contracts (planner-owned)" : "## Shared contracts (configured entry-point-owned)";
+  const placeholderInstruction = generic ? " Replace `<entry-point-role>` with the configured entry-point role before running it." : "";
+  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
+
+## Handoff Template (Architect → Entry Point)
+
+Return exactly one recommended, evidence-backed design brief for the authoritative user request to the configured entry point. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
+
+## Summary
+<describe the design problem being solved, the repository/product surface where it fits, and the evidence-backed context; do not refer to hidden session text>
+
+## Goal
+<state the one-sentence outcome this design delivers>
+
+## Key Knowledge for High Quality Bar
+<cite the inspected repository patterns and complete the architect checklist below; do not provide a high-level essay>
+- Produce exactly one recommended design for ${getArchitectFocus()}.
+- Name concrete repository paths, existing abstractions, APIs/types, state/data flow, acceptance criteria, risks, and verification steps.
+${getArchitectRequirements()}
+
+## Force Multipliers
+<name the existing abstractions, patterns, utilities, and platform conventions to reuse, and state why each reduces implementation risk or duplication>
+- Keep the design within the repository's established source-of-truth boundaries and avoid introducing a new registry or abstraction without evidence.
+
+## Files to implement (exhaustive, file-level)
+List every file or product surface the implementer must create or modify. Mark each \`(Required)\` or \`(Optional)\`. For every file, give the exact responsibility, exported types/signatures/query shape, state/data/event boundaries, and target code detailed enough to implement without guessing.
+${getFileReferenceGuidanceComment()}
+
+### \`<repo-relative/path.ext>\` (Required)
+**Change:** <precise add/modify/remove responsibility and why>
+
+\`\`\`text
+// Target code, API/type signature, query shape, or migration/backfill step.
+// Enough detail that implementation requires no invention.
+\`\`\`
+
+<add one block per file; do not collapse multiple files into a directory or vague layer>
+
+${sharedContractsHeading}
+<list cross-file interfaces, schemas, API contracts, state/data boundaries, or write exactly \`Not Applicable.\` when genuinely inapplicable>
+
+### Interfaces & types
+\`\`\`typescript
+// Shared signatures, schemas, query/mutation shapes, or state contracts.
+\`\`\`
+
+### Reference snippets
+\`\`\`typescript
+// Canonical imports, call patterns, or data-flow examples.
+\`\`\`
+
+## Requirements (acceptance criteria)
+- <one concrete, verifiable requirement per bullet; include exact data shape, API contract, migration result, and failure behavior>
+- Include repository test coverage for domain, concurrency, read-pattern, migration, and recovery risk areas.
+- Verify the implemented user-facing entry point or task-delivery path end-to-end; unit tests alone are insufficient.
+
+## What to avoid
+- Do not implement code or edit files as the architect; this handoff is advisory only.
+- Do not present alternative designs, generic advice, or requirements without concrete evidence and file-level consequences.
+- Do not invent APIs, schema fields, query shapes, indexes, or source-of-truth locations when existing repository patterns apply.
+- <explicit task-specific anti-patterns, scope boundaries, and migration/source-of-truth pitfalls>
+
+## Skills to activate
+- <relevant repository skills and why they apply, or write exactly \`Not Applicable.\` when none apply>
+
+## Out of scope
+- <explicit files, flows, behavior, or migration work the implementer must not touch>
+
+## Handoff
+Run the normal handoff command to the configured entry point with this complete design, then stop.${placeholderInstruction}
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "architect",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_architect_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/uiux-engineer-handoff-templates.ts
+function normalizeEntryPointRole2(entryPointRole) {
+  return entryPointRole.trim().toLowerCase() || "planner";
+}
+function getUiuxEngineerFocus() {
+  return "complete user flows, loading/empty/error/success states, component ownership, theme tokens and layout, keyboard and accessibility behavior, responsive details, and UI tests";
+}
+function getUiuxEngineerRequirements() {
+  return `
+- Specify complete user flows with explicit loading, empty, error, success, disabled, and retry states where applicable.
+- Define exact keyboard shortcuts, focus order, keyboard navigation, focus restoration, and accessible semantics and labels.
+- Define component hierarchy and ownership, props/state/events, data boundaries, and interaction behavior.
+- Choose concrete existing ShadCN components with the Base UI backend and lucide-react/react-icons conventions; do not write "use an appropriate component."
+- Specify Tailwind utility classes or semantic theme-token classes for layout, spacing, sizing, typography, states, responsive behavior, and dark mode.
+- Specify responsive breakpoints/layout behavior, visual feedback, destructive-action safeguards, exact files/components, and the UI/integration/accessibility test plan.`;
+}
+function getEntryPointToUiuxEngineerHandoffTemplate(entryPointRole) {
+  const entryPoint = normalizeEntryPointRole2(entryPointRole);
+  return `${getHandoffRecipientVisibilityCallout("uiux-engineer")}
+
+## Handoff Template (${entryPoint} → uiux-engineer)
+
+The automatically injected \`<user-message>\` is the authoritative request. Add only concise context that the UI/UX Engineer needs to design within the existing repository and team scope.
+
+Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getUiuxEngineerFocus()}.
+
+After completing the design, hand it back to \`${entryPoint}\` with the normal handoff command. Stop after the successful handoff; do not implement the design or delegate further work.
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "uiux-engineer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+function getUiuxEngineerToEntryPointHandoffTemplate(entryPointRole) {
+  return renderUiuxEngineerToEntryPointHandoffTemplate(normalizeEntryPointRole2(entryPointRole));
+}
+function getGenericUiuxEngineerToEntryPointHandoffTemplate() {
+  return renderUiuxEngineerToEntryPointHandoffTemplate("<entry-point-role>", true);
+}
+function renderUiuxEngineerToEntryPointHandoffTemplate(entryPoint, generic = false) {
+  const sharedContractsHeading = !generic && entryPoint === "planner" ? "## Shared contracts (planner-owned)" : "## Shared contracts (configured entry-point-owned)";
+  const placeholderInstruction = generic ? " Replace `<entry-point-role>` with the configured entry-point role before running it." : "";
+  return `${getHandoffRecipientVisibilityCallout(entryPoint)}
+
+## Handoff Template (UI/UX Engineer → Entry Point)
+
+Return exactly one recommended, evidence-backed design brief for the authoritative user request to the configured entry point. This is an advisory handback: do not implement code, edit files, spawn subagents, present alternatives, or expand scope. The injected \`<handoff-templates>\` block is the authoritative structure for this handoff; complete every section in order. Use \`Not Applicable.\` only when a section is genuinely inapplicable, with no explanation or filler.
+
+## Summary
+<describe the design problem being solved, the repository/product surface where it fits, and the evidence-backed context; do not refer to hidden session text>
+
+## Goal
+<state the one-sentence outcome this design delivers>
+
+## Key Knowledge for High Quality Bar
+<cite the inspected repository patterns and complete the UI/UX engineer checklist below; do not provide a high-level essay>
+- Produce exactly one recommended design for ${getUiuxEngineerFocus()}.
+- Name concrete repository paths, existing components/tokens, props/state/events, data boundaries, acceptance criteria, risks, and verification steps.
+${getUiuxEngineerRequirements()}
+
+## Force Multipliers
+<name the existing components, patterns, tokens, utilities, and platform conventions to reuse, and state why each reduces implementation risk or duplication>
+- Keep the design within the repository's established source-of-truth boundaries and avoid introducing a new registry or abstraction without evidence.
+
+## Files to implement (exhaustive, file-level)
+List every file or product surface the implementer must create or modify. Mark each \`(Required)\` or \`(Optional)\`. For every file, give the exact responsibility, exported types/signatures/props, state/data/event boundaries, component hierarchy, and target Tailwind/theme-token snippet detailed enough to implement without guessing.
+${getFileReferenceGuidanceComment()}
+
+### \`<repo-relative/path.ext>\` (Required)
+**Change:** <precise add/modify/remove responsibility and why>
+
+\`\`\`text
+// Component hierarchy, props/state/events, test structure, or exact
+// Tailwind/theme-token classes. Enough detail that implementation requires no invention.
+\`\`\`
+
+<add one block per file; do not collapse multiple files into a directory or vague layer>
+
+${sharedContractsHeading}
+<list cross-file interfaces, component/data contracts, state boundaries, or write exactly \`Not Applicable.\` when genuinely inapplicable>
+
+### Interfaces & types
+\`\`\`typescript
+// Shared props, state, events, query shapes, or accessibility contracts.
+\`\`\`
+
+### Reference snippets
+\`\`\`tsx
+// Canonical component imports, hook usage, keyboard wiring, or layout examples.
+\`\`\`
+
+## Requirements (acceptance criteria)
+- <one concrete, verifiable requirement per bullet; include exact states, interactions, semantics, classes/tokens, and responsive behavior>
+- Include UI, integration, and accessibility test coverage for the design's risk areas.
+- Verify the implemented user-facing entry point end-to-end; unit tests alone are insufficient.
+
+## What to avoid
+- Do not implement code or edit files as the UI/UX engineer; this handoff is advisory only.
+- Do not present alternative designs, generic advice, or requirements without concrete evidence and file-level consequences.
+- Do not invent components, props, tokens, keyboard behavior, or source-of-truth locations when existing repository patterns apply.
+- <explicit task-specific anti-patterns, scope boundaries, and destructive-action/source-of-truth pitfalls>
+
+## Skills to activate
+- <relevant repository skills and why they apply, or write exactly \`Not Applicable.\` when none apply>
+
+## Out of scope
+- <explicit files, flows, behavior, or migration work the implementer must not touch>
+
+## Handoff
+Run the normal handoff command to the configured entry point with this complete design, then stop.${placeholderInstruction}
+
+\`\`\`bash
+${handoffCommand({
+    chatroomId: "<chatroom-id>",
+    role: "uiux-engineer",
+    nextRole: entryPoint,
+    cliEnvPrefix: ""
+  })}
+\`\`\``;
+}
+var init_uiux_engineer_handoff_templates = __esm(() => {
+  init_command2();
+});
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/architect.ts
+var duoArchitectHandoffContract;
+var init_architect = __esm(() => {
+  init_architect_handoff_templates();
+  duoArchitectHandoffContract = {
+    role: "architect",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: () => getArchitectToEntryPointHandoffTemplate("planner")
+    }
+  };
+});
+
 // ../../services/backend/prompts/utils/code-change-verification.ts
 var CODE_CHANGE_VERIFICATION_CONFIRMATION = "- [ ] I confirm that I have run typecheck and tests for the project (only required if code changes were made)";
 
@@ -106865,15 +107521,6 @@ ${getDelegationBriefDisclosureComment()}`;
 }
 var DELEGATION_BRIEF_DISCLOSURE_CHECKBOX = "- [ ] I confirm the delegation brief is fully met: all (Required) files done, verified end-to-end, acceptance criteria pass";
 
-// ../../services/backend/prompts/utils/file-reference-guidance.ts
-function getFileReferenceGuidanceComment() {
-  return `<!-- File references (clickable in workspace UI): use repo-relative paths with a file extension — e.g. \`apps/webapp/src/modules/chatroom/foo.ts\` or [apps/webapp/src/foo.ts](apps/webapp/src/foo.ts). Avoid absolute paths, file:// prefixes, and paths without / or extension. -->`;
-}
-function getFileReferenceProofOfCompletionExample() {
-  return `${getFileReferenceGuidanceComment()}
-- \`apps/webapp/src/path/to/file.ts\` — <what changed and why>`;
-}
-
 // ../../services/backend/prompts/utils/handoff-section-guidance.ts
 function getHandoffNotApplicableSectionComment(context5) {
   return `<!-- REQUIRED. ${context5}, or write exactly "${HANDOFF_NOT_APPLICABLE_EXACT_TEXT}" with no explanation. Do not omit this section. -->`;
@@ -107014,214 +107661,6 @@ var init_builder = __esm(() => {
   };
 });
 
-// ../../services/backend/src/domain/usecase/enhancer/enhancer-handoff-content.ts
-var ENHANCER_USER_MESSAGE_PLACEHOLDER = "{{USER_MESSAGE}}";
-
-// ../../services/backend/prompts/utils/data-query-design.ts
-function getDataQueryDesignTemplateBlock() {
-  return `## Persistent state and query pattern design
-
-**Goal:** Small updates must not cause large cache invalidations. High-frequency writes use projections to smaller tables.
-
-### 1. Sources of concern
-| Source | Write frequency | Read pattern | Risk |
-|--------|---------------|--------------|------|
-| \`<table/mutation>\` | \`<frequency>\` | \`<pattern>\` | \`<scan / hot partition>\` |
-
-### 2. Schema design
-**Hot path:** \`<table>\` — fields, projection from \`<source>\`
-**Cold path:** \`<table>\` — …
-
-\`\`\`typescript
-// target schema shape
-\`\`\`
-
-### 3. Index design (within limits)
-| Table | Index | Serves query | Budget |
-|-------|-------|--------------|--------|
-
-### 4. Query design (within limits)
-| Query | Index | Rows scanned | Timeout | Invalidation scope |
-|-------|-------|--------------|---------|-------------------|
-
-\`\`\`typescript
-// target query signature
-\`\`\`
-
-<!-- Write exactly "Not Applicable." for the entire section if no persistence changes -->`;
-}
-
-// ../../services/backend/prompts/utils/frontend-design-ux-checklist.ts
-function getFrontendDesignUxPlanningPrinciplesBlock() {
-  return `<!-- Ground every flow in user history and repository patterns. Recommend one existing pattern when multiple exist; do not prescribe style choices the project has not adopted. -->`;
-}
-function getFrontendDesignUxFlowChecklistBlock() {
-  return `**UX quality (complete for every interactive step in this flow):**
-- **States:** loading | empty | error | success — no blank panels, silent failures, or missing retry affordances
-- **Layout:** stable across async transitions — no layout shift when content arrives or state changes
-- **Patterns:** consistent with existing project components — cite the chosen pattern and repo-relative file
-- **Shortcuts:** aligned with project keyboard/shortcut conventions; document tab order and gaps
-- **Feedback:** timely response for async user actions
-- **Interaction affordance:** pointer cursor (or project equivalent) on clickable elements
-- **Safeguards:** confirmation before destructive actions; bulk operations confirmed with scope summary`;
-}
-
-// ../../services/backend/prompts/utils/enhancer-feedback-template-body.ts
-function getEnhancerFeedbackTemplateBody() {
-  return `<handoff-overview>
-## Summary
-<one paragraph: what we're building and the single design direction>
-
-## User intent and constraints
-<explicit requirements from user messages; hard constraints that must not be violated>
-</handoff-overview>
-
-<!-- UI collapses proofs, direction, frontend design, data design, and notes by default; overview and action required are expanded -->
-
-<handoff-proofs>
-## Repository evidence
-<files read, current behavior verified, patterns reused — cite repo-relative paths and short snippets only>
-
-${getHandoffQualityPrinciplesSectionBlock("design")}
-</handoff-proofs>
-
-<handoff-direction>
-## Recommended design
-<!-- ONE design only. No Option A/B/C. -->
-
-<2–4 sentences: the chosen architecture and why it fits the request and existing system>
-</handoff-direction>
-
-<handoff-frontend-design>
-## Frontend / user-centric design
-
-${getFrontendDesignUxPlanningPrinciplesBlock()}
-
-### Flow 1: <name>
-**Entry:** User visits \`<route/page>\` from \`<source>\`.
-
-| Step | User action | System response | UI state |
-|------|-------------|-----------------|----------|
-| 1 | User clicks \`<element label>\` | \`<navigation / modal / fetch>\` | \`<loading → success/error>\` |
-
-${getFrontendDesignUxFlowChecklistBlock()}
-
-**Expected interactions per element:**
-- \`<ElementName>\` (\`apps/webapp/src/...\`): click → \`<handler>\`; keyboard: \`<tab order>\`; disabled when \`<condition>\`
-
-### Element, style, and layout specification
-
-#### \`<ComponentName>\` — \`apps/webapp/src/path/to/Component.tsx\`
-**Change:** <create | modify>
-
-**Layout:** \`<div className="...">\` — flex/grid, gaps, breakpoints
-
-**States:** loading | empty | error | success
-
-\`\`\`tsx
-export function ComponentName({ ... }: Props) {
-  // target structure — props, classNames, branches
-}
-\`\`\`
-
-<!-- Repeat per component; write exactly "Not Applicable." for the entire section if no UI -->
-</handoff-frontend-design>
-
-<handoff-data-design>
-${getDataQueryDesignTemplateBlock()}
-</handoff-data-design>
-
-<handoff-notes>
-## Open questions for user
-<decisions only the user can make, or write "Not Applicable.">
-</handoff-notes>
-
-<handoff-action>
-## Recommended implementation sequence
-<!-- Ordered slices for the planner — references files from design sections. For large or multi-surface revisions, activate the defragmentation skill before delegating. -->
-
-1. …
-2. …
-
-## Files touched (index)
-- \`apps/webapp/src/...\` — …
-- \`services/backend/convex/...\` — …
-</handoff-action>`;
-}
-var init_enhancer_feedback_template_body = __esm(() => {
-  init_handoff_quality_principles();
-});
-
-// ../../services/backend/prompts/enhancer/handoff-templates.ts
-function roleLabel(role) {
-  return role.charAt(0).toUpperCase() + role.slice(1).toLowerCase();
-}
-function getEntryPointToEnhancerHandoffTemplate(entryPointRole) {
-  const label = roleLabel(entryPointRole);
-  return `**Planning Request (${label} → Enhancer)** — after reading the user message and any pinned chatroom context, fill only <additional-context> below. The system injects the user message automatically — do not copy it.
-
-\`\`\`markdown
-<user-message>
-<!-- Injected automatically from the originating user message — do not edit or copy the user message here -->
-${ENHANCER_USER_MESSAGE_PLACEHOLDER}
-</user-message>
-
-<additional-context>
-## Goal
-<what the user wants in plain language — one short paragraph>
-</additional-context>
-\`\`\`
-
-After handoff succeeds, **end your turn immediately**. The enhancer independently downloads the originating message history and returns design input as your next ${entryPointRole.toLowerCase()} task.`;
-}
-function getEnhancerToEntryPointHandoffTemplate(entryPointRole) {
-  const normalizedRole = entryPointRole.toLowerCase();
-  const label = roleLabel(entryPointRole);
-  return `**Design Input (Enhancer → ${label})**
-
-You are the design authority for this request. Recover conversation history, inspect the repository, and return **one** complete design — not options. The ${normalizedRole} agent verifies your design and delegates implementation.
-
-**Rules:**
-- Design first — complete frontend and data/query sections before implementation sequencing.
-- **No alternative approaches** — one \`Recommended design\` only.
-- Frontend and data sections: code granularity (component names, props, classes, file paths, schema, indexes, queries).
-- Complete per-flow **UX quality** checklist in frontend design — states, layout stability, patterns, safeguards.
-- For large or multi-surface revisions, note in implementation sequence that the entry point should activate the \`defragmentation\` skill.
-- In \`<handoff-proofs>\`, complete **Proof of Principles** for how this design satisfies each quality principle (or "Not Applicable.").
-- Write "Not Applicable." only when a major design section truly does not apply.
-
-\`\`\`markdown
-${getEnhancerFeedbackTemplateBody()}
-\`\`\`
-
-Return only the design input markdown — no preamble. Follow this structure; use "Not Applicable." where a major section does not apply.`;
-}
-var init_handoff_templates = __esm(() => {
-  init_enhancer_feedback_template_body();
-});
-
-// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer-to-planner.ts
-function getEnhancerToPlannerHandoffTemplate() {
-  return getEnhancerToEntryPointHandoffTemplate("planner");
-}
-var init_enhancer_to_planner = __esm(() => {
-  init_handoff_templates();
-});
-
-// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer.ts
-var duoEnhancerHandoffContract;
-var init_enhancer = __esm(() => {
-  init_enhancer_to_planner();
-  duoEnhancerHandoffContract = {
-    role: "enhancer",
-    receivesFrom: ["planner"],
-    returnsTo: ["planner"],
-    outboundTemplates: {
-      planner: () => getEnhancerToPlannerHandoffTemplate()
-    }
-  };
-});
-
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-builder.ts
 function getPlannerToBuilderHandoffTemplate() {
   return `${getHandoffRecipientVisibilityCallout("builder")}
@@ -107298,14 +107737,6 @@ Keep one slice ≈ one focused review surface. Delegate slices incrementally —
 }
 var init_planner_to_builder = () => {};
 
-// ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-enhancer.ts
-function getPlannerToEnhancerHandoffTemplate() {
-  return getEntryPointToEnhancerHandoffTemplate("planner");
-}
-var init_planner_to_enhancer = __esm(() => {
-  init_handoff_templates();
-});
-
 // ../../services/backend/prompts/utils/context-disclosure.ts
 function getContextReadDisclosureComment(params = {}) {
   const command = contextReadCommand(params);
@@ -107493,16 +107924,18 @@ var init_chat_handoff_template = () => {};
 var duoPlannerHandoffContract;
 var init_planner = __esm(() => {
   init_planner_to_builder();
-  init_planner_to_enhancer();
   init_planner_to_user();
   init_chat_handoff_template();
+  init_architect_handoff_templates();
+  init_uiux_engineer_handoff_templates();
   duoPlannerHandoffContract = {
     role: "planner",
-    receivesFrom: ["user", "builder", "enhancer"],
-    returnsTo: ["builder", "enhancer", "user"],
+    receivesFrom: ["user", "builder", "architect", "uiux-engineer"],
+    returnsTo: ["builder", "architect", "uiux-engineer", "user"],
     outboundTemplates: {
       builder: () => getPlannerToBuilderHandoffTemplate(),
-      enhancer: () => getPlannerToEnhancerHandoffTemplate(),
+      architect: () => getEntryPointToArchitectHandoffTemplate("planner"),
+      "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("planner"),
       user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getPlannerToUserReportTemplate({
         chatroomId: query.chatroomId,
         role: query.role,
@@ -107512,6 +107945,20 @@ var init_planner = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/uiux-engineer.ts
+var duoUiuxEngineerHandoffContract;
+var init_uiux_engineer = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+  duoUiuxEngineerHandoffContract = {
+    role: "uiux-engineer",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: () => getUiuxEngineerToEntryPointHandoffTemplate("planner")
+    }
+  };
+});
+
 // ../../services/backend/prompts/cli/handoff-templates/contracts.ts
 function validateRoleHandoffContracts(contracts) {
   const byRole = new Map;
@@ -107552,14 +107999,16 @@ function getDuoHandoffTemplate(query) {
   return getter?.(query) ?? null;
 }
 var DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandoffContracts;
-var init_handoff_templates2 = __esm(() => {
+var init_handoff_templates = __esm(() => {
+  init_architect();
   init_builder();
-  init_enhancer();
   init_planner();
+  init_uiux_engineer();
   DUO_ROLE_HANDOFF_CONTRACTS = [
     duoPlannerHandoffContract,
     duoBuilderHandoffContract,
-    duoEnhancerHandoffContract
+    duoArchitectHandoffContract,
+    duoUiuxEngineerHandoffContract
   ];
   validatedDuoRoleHandoffContracts = (() => {
     validateRoleHandoffContracts(DUO_ROLE_HANDOFF_CONTRACTS);
@@ -107567,16 +108016,16 @@ var init_handoff_templates2 = __esm(() => {
   })();
 });
 
-// ../../services/backend/prompts/teams/solo/handoff-templates/enhancer.ts
-var soloEnhancerHandoffContract;
-var init_enhancer2 = __esm(() => {
-  init_handoff_templates();
-  soloEnhancerHandoffContract = {
-    role: "enhancer",
+// ../../services/backend/prompts/teams/solo/handoff-templates/architect.ts
+var soloArchitectHandoffContract;
+var init_architect2 = __esm(() => {
+  init_architect_handoff_templates();
+  soloArchitectHandoffContract = {
+    role: "architect",
     receivesFrom: ["solo"],
     returnsTo: ["solo"],
     outboundTemplates: {
-      solo: () => getEnhancerToEntryPointHandoffTemplate("solo")
+      solo: () => getArchitectToEntryPointHandoffTemplate("solo")
     }
   };
 });
@@ -107599,14 +108048,16 @@ var init_solo_to_user = __esm(() => {
 var soloHandoffContract;
 var init_solo = __esm(() => {
   init_solo_to_user();
-  init_handoff_templates();
   init_chat_handoff_template();
+  init_architect_handoff_templates();
+  init_uiux_engineer_handoff_templates();
   soloHandoffContract = {
     role: "solo",
-    receivesFrom: ["user", "enhancer"],
-    returnsTo: ["user", "enhancer"],
+    receivesFrom: ["user", "architect", "uiux-engineer"],
+    returnsTo: ["architect", "uiux-engineer", "user"],
     outboundTemplates: {
-      enhancer: () => getEntryPointToEnhancerHandoffTemplate("solo"),
+      architect: () => getEntryPointToArchitectHandoffTemplate("solo"),
+      "uiux-engineer": () => getEntryPointToUiuxEngineerHandoffTemplate("solo"),
       user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getSoloToUserReportTemplate({
         chatroomId: query.chatroomId,
         role: query.role,
@@ -107616,6 +108067,20 @@ var init_solo = __esm(() => {
   };
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/uiux-engineer.ts
+var soloUiuxEngineerHandoffContract;
+var init_uiux_engineer2 = __esm(() => {
+  init_uiux_engineer_handoff_templates();
+  soloUiuxEngineerHandoffContract = {
+    role: "uiux-engineer",
+    receivesFrom: ["solo"],
+    returnsTo: ["solo"],
+    outboundTemplates: {
+      solo: () => getUiuxEngineerToEntryPointHandoffTemplate("solo")
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/index.ts
 function listSoloRoleHandoffContracts() {
   return validatedSoloRoleHandoffContracts;
@@ -107628,12 +108093,14 @@ function getSoloHandoffTemplate(query) {
   return getter?.(query) ?? null;
 }
 var SOLO_ROLE_HANDOFF_CONTRACTS, validatedSoloRoleHandoffContracts;
-var init_handoff_templates3 = __esm(() => {
-  init_enhancer2();
+var init_handoff_templates2 = __esm(() => {
+  init_architect2();
   init_solo();
+  init_uiux_engineer2();
   SOLO_ROLE_HANDOFF_CONTRACTS = [
     soloHandoffContract,
-    soloEnhancerHandoffContract
+    soloArchitectHandoffContract,
+    soloUiuxEngineerHandoffContract
   ];
   validatedSoloRoleHandoffContracts = (() => {
     validateRoleHandoffContracts(SOLO_ROLE_HANDOFF_CONTRACTS);
@@ -107691,13 +108158,21 @@ function getHandoffTemplate(query) {
     return getSoloHandoffTemplate(query);
   return null;
 }
-var init_handoff_templates4 = __esm(() => {
+var init_handoff_templates3 = __esm(() => {
+  init_handoff_templates();
   init_handoff_templates2();
-  init_handoff_templates3();
 });
 
 // ../../services/backend/prompts/cli/handoff/view-template.ts
 function viewHandoffTemplate(params) {
+  if (params.nextRole === undefined) {
+    const role = params.role.trim().toLowerCase();
+    if (role === "architect")
+      return getGenericArchitectToEntryPointHandoffTemplate();
+    if (role === "uiux-engineer")
+      return getGenericUiuxEngineerToEntryPointHandoffTemplate();
+    throw new Error(`Role-only handoff template viewing is supported only for architect or uiux-engineer, not ${params.role}`);
+  }
   const template = getHandoffTemplate({
     fromRole: params.role,
     toRole: params.nextRole,
@@ -107710,7 +108185,9 @@ function viewHandoffTemplate(params) {
   return template;
 }
 var init_view_template2 = __esm(() => {
-  init_handoff_templates4();
+  init_architect_handoff_templates();
+  init_uiux_engineer_handoff_templates();
+  init_handoff_templates3();
 });
 
 // src/commands/handoff/view-template.ts
@@ -107755,12 +108232,12 @@ function listHandoffTemplatesCommand(params) {
   });
   if (!listing) {
     const teamId = params.teamId ?? "duo";
-    throw new Error(`No handoff contract for role "${params.role}" in team "${teamId}". Known roles: planner, builder, enhancer (duo) or solo, enhancer (solo).`);
+    throw new Error(`No handoff contract for role "${params.role}" in team "${teamId}". Known roles: planner, builder (duo) or solo.`);
   }
   return formatHandoffTemplateListing(listing);
 }
 var init_list_templates = __esm(() => {
-  init_handoff_templates4();
+  init_handoff_templates3();
 });
 
 // src/commands/handoff/list-templates.ts
@@ -107944,36 +108421,26 @@ function getHandoffTurnEndGuidance(nextRole) {
   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/sections/activated-skills.ts
 var init_activated_skills = () => {};
 
 // ../../services/backend/prompts/cli/backlog/command.ts
-var init_command2 = __esm(() => {
+var init_command3 = __esm(() => {
   init_stdin_heredoc();
 });
 
 // ../../services/backend/src/domain/usecase/skills/modules/backlog/index.ts
 var init_backlog = __esm(() => {
-  init_command2();
+  init_command3();
 });
 
 // ../../services/backend/src/domain/usecase/skills/modules/code-review/index.ts
 var init_code_review = () => {};
-
 // ../../services/backend/src/domain/usecase/skills/modules/data-design/index.ts
 var init_data_design = () => {};
 
 // ../../services/backend/src/domain/usecase/skills/modules/defragmentation/index.ts
 var init_defragmentation = () => {};
-
 // ../../services/backend/src/domain/usecase/skills/modules/user-centricity/index.ts
 var init_user_centricity = () => {};
 
@@ -108062,19 +108529,17 @@ var init_general_knowledge = __esm(() => {
   init_utils3();
 });
 
-// ../../services/backend/prompts/cli/handoff/command.ts
-var init_command3 = __esm(() => {
-  init_stdin_heredoc();
-});
-
 // ../../services/backend/prompts/sections/commands-reference.ts
 var init_commands_reference = __esm(() => {
   init_general_knowledge();
   init_command();
   init_reminder();
-  init_command3();
+  init_command2();
   init_utils3();
 });
+
+// ../../services/backend/prompts/cli/roles/architect.ts
+var init_architect3 = () => {};
 // ../../services/backend/prompts/cli/sections/core-responsibilities.ts
 var init_core_responsibilities = () => {};
 // ../../services/backend/prompts/cli/sections/handoff-rules.ts
@@ -108098,24 +108563,15 @@ 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();
   init_sections();
 });
 
+// ../../services/backend/prompts/cli/roles/uiux-engineer.ts
+var init_uiux_engineer3 = () => {};
+
 // ../../services/backend/prompts/cli/roles/planner-guidance-context.ts
 var init_planner_guidance_context = __esm(() => {
   init_env();
@@ -108127,12 +108583,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_architect3();
   init_builder2();
-  init_enhancer3();
   init_planner2();
-  init_solo2();
+  init_uiux_engineer3();
+  init_fromContext();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/builder.ts
@@ -108147,20 +108609,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
@@ -108169,7 +108626,9 @@ var init_role_guidance = __esm(() => {
 });
 
 // ../../services/backend/prompts/templates.ts
-var init_templates = () => {};
+var init_templates = __esm(() => {
+  init_agent_role();
+});
 
 // ../../services/backend/prompts/sections/role-identity.ts
 var init_role_identity = __esm(() => {
@@ -108216,40 +108675,12 @@ var init_session_vs_chatroom_task = () => {};
 // ../../services/backend/prompts/review-guidelines/index.ts
 var init_review_guidelines = () => {};
 // ../../services/backend/prompts/generator.ts
-function isEnhancerRequestQueuedHandoff(params) {
-  return params.enhancerRequestQueued === true && params.nextRole.toLowerCase() === "enhancer";
-}
-function getEnhancerRequestQueuedConfirmationLines(nativeIntegration) {
-  const turnEndRule = nativeIntegration ? "**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, monitor the enhancer, or re-submit the handoff. The system delivers independent planning input as your next task when analysis completes." : "**Run get-next-task now and end your turn — stop tool calls. The system will send you a message when further action is required.** Do **not** wait for enhancer input, poll, monitor the enhancer, or re-submit the handoff.";
-  return [
-    "✅ User request queued for handoff enhancer",
-    "",
-    "The user request was sent to the handoff enhancer (async). You will receive independent planning input as your next task when analysis completes.",
-    turnEndRule
-  ];
-}
 function generateHandoffOutput(params) {
-  const {
-    role,
-    nextRole,
-    chatroomId,
-    convexUrl,
-    supportsNativeIntegration,
-    enhancerRequestQueued
-  } = params;
+  const { role, nextRole, chatroomId, convexUrl, supportsNativeIntegration } = params;
   const cliEnvPrefix = getCliEnvPrefix(convexUrl);
-  const enhancerRequest = isEnhancerRequestQueuedHandoff({
-    nextRole,
-    enhancerRequestQueued
-  });
-  const lines = [];
-  if (enhancerRequest) {
-    lines.push(...getEnhancerRequestQueuedConfirmationLines(supportsNativeIntegration));
-  } else {
-    lines.push(`✅ Chatroom task completed and handed off to ${nextRole}`);
-  }
+  const lines = [`✅ Chatroom task completed and handed off to ${nextRole}`];
   if (supportsNativeIntegration) {
-    lines.push(enhancerRequest ? getNativeEnhancerRequestTurnEndGuidance() : getNativeHandoffTurnEndGuidance(nextRole));
+    lines.push(getNativeHandoffTurnEndGuidance(nextRole));
   } else {
     lines.push("");
     lines.push("✅ Level B complete (chatroom task handed off).");
@@ -108280,6 +108711,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 +108751,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 +108823,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 };
   }));
@@ -108413,8 +108857,7 @@ var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
       nextRole,
       chatroomId,
       convexUrl,
-      supportsNativeIntegration: result.supportsNativeIntegration,
-      enhancerRequestQueued: result.enhancerRequestQueued === true
+      supportsNativeIntegration: result.supportsNativeIntegration
     }));
   });
 });
@@ -108422,7 +108865,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 +110155,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 +110175,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 +110591,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 +110862,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 +110897,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 +111364,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 +111402,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 +111428,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 +111826,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 +112248,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 +112543,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;
@@ -112617,6 +113006,7 @@ function assembleDaemonSessionInit(args2) {
     convexUrl,
     backend: deps.backend,
     configurationService: agentConfigRegistry,
+    handoffRepository: createTaskHandoffRepository(resolveTaskHandoffRepositoryPath(machineId)),
     logEvent: activeLogEvent ?? (async () => {
       return;
     })
@@ -112657,9 +113047,6 @@ class NetworkRetryError {
     this.attempt = attempt;
   }
 }
-function getActiveLogSink() {
-  return activeLogSink;
-}
 async function initDaemon(options = {}) {
   activeLogSink = options.logSink;
   activeLogEvent = options.logEvent;
@@ -112860,6 +113247,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();
@@ -112874,6 +113262,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({
@@ -117228,16 +117617,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);
       }
@@ -117248,7 +117637,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 [];
@@ -117268,7 +117657,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),
@@ -117280,7 +117669,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(`
@@ -117307,7 +117696,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 [];
@@ -117356,11 +117745,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 {}
   }
@@ -117429,7 +117818,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)
@@ -117445,7 +117834,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)) {
@@ -117458,7 +117847,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);
@@ -117481,7 +117870,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;
@@ -118056,7 +118445,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) => {
@@ -118067,7 +118456,7 @@ async function runRestartOrchestrator(deps, event) {
         agentHarness: event.agentHarness,
         model: event.model,
         workingDir: event.workingDir,
-        reason: "user.restart",
+        reason: AgentStartReasonCode.USER_RESTART,
         wantResume: event.wantResume
       }, context5.signal);
     });
@@ -118081,7 +118470,7 @@ async function runRestartOrchestrator(deps, event) {
       await deps.runSerializedForAgent({ chatroomId, role, workingDir: event.workingDir }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, (ops, context5) => ops.stopAgent({
         chatroomId,
         role,
-        reason: "user.restart",
+        reason: AgentStartReasonCode.USER_RESTART,
         pid: spawnResult.pid,
         workingDir: event.workingDir
       }, context5.signal));
@@ -118112,12 +118501,12 @@ async function runRestartOrchestrator(deps, event) {
 }
 var init_restart_orchestrator = __esm(() => {
   init_reliability();
+  init_agent();
   init_build_agent_restart_event();
   init_restart_orchestrator_in_flight();
   init_api3();
   init_convex_error();
   init_execution_kind();
-  init_service_interfaces();
 });
 
 // src/daemon/entry/bridge/agent-control-bridge.ts
@@ -118272,19 +118661,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;
@@ -118301,7 +118677,6 @@ var onRequestStartAgentEffect = (event) => exports_Effect.gen(function* () {
       deadline: event.deadline,
       wantResume: event.wantResume
     });
-    await drainPendingEnhancerJobsIfRegistered();
   });
 });
 var init_on_request_start_agent = __esm(() => {
@@ -118637,435 +119012,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(".");
@@ -119184,7 +119143,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"))
@@ -119212,7 +119171,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);
@@ -119230,7 +119189,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" };
       }
@@ -120034,16 +119993,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) {
@@ -120074,11 +120033,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 = [];
@@ -121214,9 +121173,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;
@@ -121243,7 +121202,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;
@@ -122632,8 +122591,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);
@@ -122647,10 +122606,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 {
@@ -122710,7 +122669,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
@@ -123088,12 +123047,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();
@@ -124081,7 +124040,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",
@@ -124180,7 +124139,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;
   }
@@ -124258,7 +124217,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;
@@ -125333,16 +125292,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;
@@ -125360,6 +125319,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(() => {
@@ -125389,7 +125361,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;
@@ -125430,7 +125401,6 @@ function createDaemonRuntime(deps) {
     taskInboxHandle?.stop();
     logObserverSubscriptionHandle?.stop();
     agenticQueryWorkerHandle?.stop();
-    enhancerWorkerHandle?.stop();
   };
   const shutdown = async () => {
     if (isShuttingDown)
@@ -125548,7 +125518,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
@@ -125585,7 +125554,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();
@@ -125593,7 +125561,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();
@@ -125636,21 +125603,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);
@@ -125720,14 +125672,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();
 });
@@ -126008,7 +125958,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);
@@ -126041,15 +125990,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 = () => {};
 
@@ -126067,13 +126015,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) {
@@ -126109,9 +126050,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:
   }
 }
@@ -126219,80 +126157,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)
@@ -126609,7 +126473,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") {
@@ -126640,8 +126503,7 @@ function startAllSubscribers(deps) {
         fileContent.stop(),
         fileWrite.stop(),
         agenticQuerySession.stop(),
-        agenticQueryPrompt.stop(),
-        enhancerJob.stop()
+        agenticQueryPrompt.stop()
       ]);
     }
   };
@@ -126651,7 +126513,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();
@@ -126700,12 +126561,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);
   }
@@ -134200,19 +134061,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];
@@ -134225,7 +134086,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();
@@ -134242,7 +134103,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") {
@@ -134291,6 +134152,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") {
@@ -134301,6 +134170,7 @@ function normalizeError(err) {
   return { code: "internal_error", message: "Unknown error" };
 }
 var init_normalize_error = __esm(() => {
+  init_values();
   init_zod();
 });
 
@@ -134431,6 +134301,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;
@@ -134450,13 +134330,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) });
       }
@@ -134640,7 +134529,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,
@@ -134696,6 +134586,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;
@@ -134730,6 +134694,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}/`)));
@@ -134787,7 +134756,8 @@ async function startDaemon() {
     eventStreamHub,
     backend: init2.backend,
     sessionId: init2.sessionId,
-    debugState
+    debugState,
+    cliGateway
   });
   resolveBoundPort(localWeb.port);
   const subscribers = startAllSubscribers({
@@ -134848,6 +134818,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
@@ -135657,10 +135628,10 @@ teamCommand.command("set").description("Set the team preset for a chatroom").req
   const { setTeam: setTeam2 } = await Promise.resolve().then(() => (init_team(), exports_team));
   await setTeam2(options.chatroomId, options.team);
 });
-handoffCommandGroup.command("view-template").description("Print the handoff message template for a role pair").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
+handoffCommandGroup.command("view-template").description("Print a handoff message template; omit --next-role to inspect a generic architect or UI/UX engineer template").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
   const parentOpts = this.parent?.opts() ?? {};
-  if (!parentOpts.role || !parentOpts.nextRole) {
-    console.error(parentOpts.role ? `error: required option '--next-role <nextRole>' not specified` : `error: required option '--role <role>' not specified`);
+  if (!parentOpts.role) {
+    console.error(`error: required option '--role <role>' not specified`);
     process.exit(1);
   }
   const { printHandoffViewTemplate: printHandoffViewTemplate2 } = await Promise.resolve().then(() => (init_view_template3(), exports_view_template));
@@ -136104,4 +136075,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=812FE18B15DD283564756E2164756E21
+//# debugId=318DFD58C705B11264756E2164756E21