chatroom-cli 1.115.3 → 1.116.0

package/dist/index.js

@@ -27949,7 +27949,7 @@ var init_v_literals_of = __esm(() => {
 });
 
 // ../../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, agentStopReasonValidator, isAgentStopReason = (value) => AGENT_STOP_REASONS.includes(value), MODEL_SOURCES, ModelSourceEnum, modelSourceValidator;
+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();
@@ -28017,7 +28017,6 @@ var init_agent = __esm(() => {
   ];
   agentPostStopDesiredStateValidator = v.union(v.literal("running"), v.literal("stopped"));
   AgentStopReasonEnum = Object.fromEntries(AGENT_STOP_REASONS.map((r) => [r, r]));
-  agentStopReasonValidator = v.union(...toLiteralValidators(AGENT_STOP_REASONS));
   MODEL_SOURCES = ["team_config", "none"];
   ModelSourceEnum = Object.fromEntries(MODEL_SOURCES.map((s) => [s, s]));
   modelSourceValidator = v.union(...toLiteralValidators(MODEL_SOURCES));
@@ -28127,7 +28126,7 @@ function normalizeAgentLifecycleFact(raw) {
       emittedAt: Number(rest.emittedAt)
     };
   }
-  if (kind === "spawned" || kind === "exited" || kind === "activity" || kind === "turn_failed") {
+  if (kind === "spawned" || kind === "exited" || kind === "activity" || kind === "turn_failed" || kind === "status" || kind === "chatroom_shutdown_complete") {
     return rest;
   }
   throw new Error(`Unknown agent lifecycle fact kind: ${String(kind)}`);
@@ -28144,35 +28143,89 @@ function buildActivityLifecycleFact(params) {
     emittedAt
   };
 }
+function buildAgentStatusFact(params) {
+  const emittedAt = params.emittedAt ?? Date.now();
+  return {
+    kind: "status",
+    chatroomId: params.chatroomId,
+    role: params.role,
+    status: params.status,
+    ...params.errorSource ? { errorSource: params.errorSource } : {},
+    ...params.errorCode ? { errorCode: params.errorCode } : {},
+    ...params.errorMessage ? { errorMessage: params.errorMessage } : {},
+    revisionKey: buildAgentLifecycleRevisionKey("status", {
+      chatroomId: params.chatroomId,
+      role: params.role,
+      status: params.status,
+      errorCode: params.errorCode,
+      emittedAt
+    }),
+    emittedAt
+  };
+}
 function agentLifecycleDeliveryKey(machineId, fact) {
   if (fact.kind === "cleared_all_pids")
     return `${machineId}:__machine__`;
+  if (fact.kind === "chatroom_shutdown_complete")
+    return `${machineId}:${fact.chatroomId}:shutdown:${fact.commandId}`;
   return `${machineId}:${fact.chatroomId}:${fact.role.toLowerCase()}`;
 }
 function buildAgentLifecycleRevisionKey(prefix, parts2) {
   return `${prefix}:${Object.entries(parts2).filter(([, v2]) => v2 !== undefined).map(([k, v2]) => `${k}=${v2}`).join(":")}`;
 }
 
+// src/daemon/domain/entities/agent-slot.ts
+function isAgentSlotStarted(slot) {
+  return slot.state === AGENT_SLOT_STATE.RUNNING && slot.pid !== undefined;
+}
+function isAgentSlotStartInFlight(slot) {
+  return slot.state === AGENT_SLOT_STATE.SPAWNING;
+}
+function isAgentSlotActive(slot) {
+  return isAgentSlotStarted(slot) || isAgentSlotStartInFlight(slot);
+}
+function agentKey(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+var AGENT_SLOT_STATE, AGENT_START_DISPOSITION, idleSlot = () => ({ state: AGENT_SLOT_STATE.IDLE });
+var init_agent_slot = __esm(() => {
+  AGENT_SLOT_STATE = {
+    IDLE: "idle",
+    SPAWNING: "spawning",
+    RUNNING: "running",
+    STOPPING: "stopping"
+  };
+  AGENT_START_DISPOSITION = {
+    STARTED: "started",
+    ALREADY_STARTED: "already_started",
+    START_IN_PROGRESS: "start_in_progress"
+  };
+});
+
 // src/daemon/domain/usecase/check-agent-slot.ts
 function isSlotIdle(state) {
-  return state === "idle";
+  return state === AGENT_SLOT_STATE.IDLE;
 }
 function isSlotSpawning(state) {
-  return state === "spawning";
+  return state === AGENT_SLOT_STATE.SPAWNING;
 }
 function isSlotRunning(state) {
-  return state === "running";
+  return state === AGENT_SLOT_STATE.RUNNING;
 }
 function isSlotStopping(state) {
-  return state === "stopping";
+  return state === AGENT_SLOT_STATE.STOPPING;
 }
 function isTurnPhaseIdle(phase) {
   return phase === "idle";
 }
-var init_check_agent_slot = () => {};
+var AGENT_SLOT_STATES;
+var init_check_agent_slot = __esm(() => {
+  init_agent_slot();
+  AGENT_SLOT_STATES = Object.values(AGENT_SLOT_STATE);
+});
 
 // src/daemon/services/task-service/domain/usecase/native-cold-session-delivery.ts
-function snapshotRequestsNativeColdSession(task) {
+function taskRequestsNativeColdSession(task) {
   return task.requestsNativeColdSession === true;
 }
 function isColdStartEligibleSlotState(slot) {
@@ -28181,10 +28234,10 @@ function isColdStartEligibleSlotState(slot) {
   return isSlotIdle(slot.state);
 }
 function isNativeColdSessionDeliveryOwnedSpawn(task, slot) {
-  return snapshotRequestsNativeColdSession(task) && isColdStartEligibleSlotState(slot);
+  return taskRequestsNativeColdSession(task) && isColdStartEligibleSlotState(slot);
 }
 function explainColdSessionDeliveryBlock(task, slot) {
-  if (!snapshotRequestsNativeColdSession(task))
+  if (!taskRequestsNativeColdSession(task))
     return null;
   if (isChatroomStopScopeActive(task.chatroomId)) {
     return "chatroom_stop_scope_active";
@@ -28429,9 +28482,6 @@ var init_assigned_task = __esm(() => {
 });
 
 // src/daemon/services/task-service/domain/usecase/native-ready-invariant.ts
-function isAgentReadyForNativeDelivery(task, slot) {
-  return explainAgentReadyForNativeDeliveryBlock(task, slot) === null;
-}
 function explainAgentReadyForNativeDeliveryBlock(task, slot) {
   const runtimeConfig = resolveAgentRuntimeConfig(task, slot);
   if (!runtimeConfig)
@@ -28447,13 +28497,10 @@ function explainAgentReadyForNativeDeliveryBlock(task, slot) {
     return null;
   }
   if (!slot) {
-    return task.agentConfig.spawnedAgentPid == null ? "spawned_pid_missing" : `slot_missing (expectedPid=${task.agentConfig.spawnedAgentPid})`;
+    return "slot_missing";
   }
   if (!isSlotRunning(slot.state)) {
-    if (task.agentConfig.spawnedAgentPid != null && slot.pid !== task.agentConfig.spawnedAgentPid) {
-      return `pid_mismatch (slotPid=${slot.pid ?? "none"}, expectedPid=${task.agentConfig.spawnedAgentPid})`;
-    }
-    return `slot_not_running (slotState=${slot.state}, expectedPid=${task.agentConfig.spawnedAgentPid ?? "none"})`;
+    return `slot_not_running (slotState=${slot.state})`;
   }
   if (slot.pid == null) {
     return "slot_pid_missing";
@@ -28510,9 +28557,6 @@ var init_native_integration = __esm(() => {
 });
 
 // src/daemon/services/task-service/domain/usecase/native-task-injector-logic.ts
-function shouldDeliverNativeTask(task, opts) {
-  return explainNativeDeliveryBlock(task, opts) === null;
-}
 function explainNativeDeliveryBlock(task, opts) {
   if (!isDeliverableNativeTaskStatus(task.status)) {
     return `task_status_not_deliverable (status=${task.status})`;
@@ -28546,8 +28590,8 @@ var init_native_task_injector_logic = __esm(() => {
 // ../../services/backend/src/domain/entities/participant.ts
 var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", GET_NEXT_TASK_STARTED_ACTION = "get-next-task:started";
 
-// src/infrastructure/mappers/map-assigned-task.ts
-function mapAssignedTaskSnapshot(row) {
+// src/infrastructure/mappers/map-assigned-task-view.ts
+function mapAssignedTask(row) {
   return {
     taskId: row.taskId,
     chatroomId: row.chatroomId,
@@ -28557,11 +28601,7 @@ function mapAssignedTaskSnapshot(row) {
     createdAt: row.createdAt,
     agentConfig: {
       role: row.agentConfig.role,
-      machineId: row.agentConfig.machineId,
-      spawnedAgentPid: row.agentConfig.spawnedAgentPid,
-      desiredState: row.agentConfig.desiredState,
-      circuitState: row.agentConfig.circuitState,
-      configLifecycleRevision: row.agentConfig.configLifecycleRevision
+      machineId: row.agentConfig.machineId
     },
     assignee: row.assignee,
     participant: row.participant,
@@ -28570,7 +28610,7 @@ function mapAssignedTaskSnapshot(row) {
 }
 function mapAssignedTaskView(row) {
   return {
-    ...mapAssignedTaskSnapshot(row),
+    ...mapAssignedTask(row),
     taskContent: row.taskContent,
     taskEnvelope: row.taskEnvelope,
     startInNewSession: row.startInNewSession
@@ -28585,21 +28625,7 @@ function createConvexNativeTaskDeliveryGateway(backend2) {
         sessionId,
         machineId
       });
-      return rows.map((row) => ({
-        eventId: row._id,
-        machineId: row.machineId,
-        chatroomId: row.chatroomId,
-        taskId: row.taskId,
-        role: row.role,
-        ...row.assignee === undefined ? {} : {
-          assignee: row.assignee
-        },
-        eventType: row.eventType,
-        status: row.status,
-        createdAt: row.createdAt,
-        ...row.processedAt === undefined ? {} : { processedAt: row.processedAt },
-        task: row.task
-      }));
+      return mapPendingTaskInboxRows(rows);
     },
     markTaskInboxEventProcessed: async ({ sessionId, machineId, eventId }) => {
       const result = await backend2.mutation(api.chatroomWorkspaceTaskInbox.markProcessed, {
@@ -28642,6 +28668,23 @@ function createConvexNativeTaskDeliveryGateway(backend2) {
     }
   };
 }
+function mapPendingTaskInboxRows(rows) {
+  return rows.map((row) => ({
+    eventId: row._id,
+    machineId: row.machineId,
+    chatroomId: row.chatroomId,
+    taskId: row.taskId,
+    role: row.role,
+    ...row.assignee === undefined ? {} : {
+      assignee: row.assignee
+    },
+    eventType: row.eventType,
+    status: row.status,
+    createdAt: row.createdAt,
+    ...row.processedAt === undefined ? {} : { processedAt: row.processedAt },
+    task: row.task
+  }));
+}
 var init_convex_native_task_delivery_gateway = __esm(() => {
   init_api3();
 });
@@ -28744,8 +28787,6 @@ function stableBlockReason(reason) {
     "slot_missing",
     "slot_not_running",
     "slot_pid_missing",
-    "spawned_pid_missing",
-    "pid_mismatch",
     "harness_session_missing",
     "turn_not_idle",
     "working_dir_missing"
@@ -28797,14 +28838,17 @@ function decideNextDelivery(tasks, context5) {
   if (isSlotStopping(context5.slot?.state ?? "idle")) {
     return { kind: "wait", taskId: task.taskId, reason: "slot_stopping" };
   }
-  const coldSession = context5.snapshotRequestsNativeColdSession(task);
-  const startAllowed = blockReason.startsWith("slot_missing") || blockReason.startsWith("slot_not_running") || blockReason.startsWith("spawned_pid_missing");
+  const coldSession = context5.taskRequestsNativeColdSession(task);
+  const startAllowed = blockReason.startsWith("slot_missing") || blockReason.startsWith("slot_not_running");
   if (startAllowed && !coldSession && task.status === "pending" && isSlotIdle(context5.slot?.state ?? "idle") && runtimeConfig.workingDir) {
     return { kind: "start-agent", taskId: task.taskId };
   }
   if (blockReason.startsWith("harness_session_missing")) {
     return { kind: "wait", taskId: task.taskId, reason: "session_not_ready" };
   }
+  if (blockReason.startsWith("turn_not_idle")) {
+    return { kind: "wait", taskId: task.taskId, reason: "turn_not_idle" };
+  }
   return { kind: "blocked", taskId: task.taskId, reason: stableBlockReason(blockReason) };
 }
 var init_delivery_decision = __esm(() => {
@@ -28930,7 +28974,7 @@ class NativeTaskDeliveryCoordinator {
         deliveryInFlight: false,
         agentLifecycleInFlight: isRestartOrchestratorInFlight(firstTask.chatroomId, role),
         isNativeHarness: taskService.isNativeHarness,
-        snapshotRequestsNativeColdSession: taskService.snapshotRequestsNativeColdSession,
+        taskRequestsNativeColdSession: taskService.taskRequestsNativeColdSession,
         explainNativeDeliveryBlock: taskService.explainNativeDeliveryBlock
       });
       const attemptId = `${Date.now()}-${firstTask.taskId}`;
@@ -28970,7 +29014,6 @@ class NativeTaskDeliveryCoordinator {
             workingDir: runtimeConfig.workingDir,
             reason: AgentStartReasonEnum["platform.pending_task_wake"],
             wantResume: false,
-            lifecycleRevision: row.agentConfig.configLifecycleRevision,
             taskId: row.taskId
           }, context5.signal));
           console.log(`[NativeDelivery:execution] attempt=${attemptId} role=${role} chatroom=${row.chatroomId} task=${row.taskId} operation=start-agent result=${startResult && typeof startResult === "object" && "success" in startResult ? startResult.success : "completed"}`);
@@ -29043,7 +29086,7 @@ var init_native_task_delivery_coordinator = __esm(() => {
 
 // src/daemon/services/task-service/service/native-delivery/task-delivery-processor.ts
 async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSerializedForAgent, taskService, sessionDeps, machineId, pass, lifecycleOutbox, isTaskActive, options) {
-  const first = options.snapshots[0];
+  const first = options.tasks[0];
   if (!first)
     return;
   logNativeDeliveryTrigger(pass, first.agentConfig.role, first.chatroomId, first.taskId);
@@ -29060,7 +29103,6 @@ async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSeriali
         workingDir: runtimeConfig.workingDir,
         reason: AgentStartReasonEnum["platform.pending_task_wake"],
         wantResume: false,
-        lifecycleRevision: task.agentConfig.configLifecycleRevision,
         taskId: task.taskId
       }, context5.signal));
     },
@@ -29080,7 +29122,7 @@ async function processTasksUpdate(runtime4, effectContext2, agentMgr, runSeriali
     }
   };
   await getNativeTaskDeliveryCoordinator().reconcileRoleTasks({
-    tasks: [...options.snapshots],
+    tasks: [...options.tasks],
     pass,
     runtime: runtime4,
     effectContext: effectContext2,
@@ -29264,7 +29306,7 @@ function resolveSessionAugmentationForTask(task, role) {
   }
   return resolveSessionAugmentationForRole(role);
 }
-function taskRequestsNativeColdSession(task) {
+function taskRequestsNativeColdSession2(task) {
   if (task.taskEnvelope !== undefined) {
     return normalizeTaskEnvelope({ taskEnvelope: task.taskEnvelope }).sessionPolicy === "new";
   }
@@ -29287,12 +29329,11 @@ var init_parse_session_augmentation = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, MACHINE_COMMAND_LEASE_RENEWAL_INTERVAL_MS = 20000, MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS, AGENT_STOP_TERMINAL_RETENTION_MS, SCOPE_TARGET_STOP_TIMEOUT_MS = 1e4, AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS = 120000, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
+var HARNESS_SESSION_READY_TIMEOUT_MS = 5000, DAEMON_HEARTBEAT_INTERVAL_MS, DAEMON_HEARTBEAT_TTL_MS, AGENT_REQUEST_DEADLINE_MS = 120000, MACHINE_COMMAND_LEASE_RENEWAL_INTERVAL_MS = 20000, MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS, SCOPE_TARGET_STOP_TIMEOUT_MS = 1e4, AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS = 120000, CONNECTION_CLOSE_REQUEST_TTL_MS, ENHANCER_TERMINAL_JOB_RETENTION_MS;
 var init_reliability = __esm(() => {
   DAEMON_HEARTBEAT_INTERVAL_MS = 5 * 60000;
   DAEMON_HEARTBEAT_TTL_MS = 6 * DAEMON_HEARTBEAT_INTERVAL_MS;
   MACHINE_COMMAND_DAEMON_ROUTINE_TTL_MS = 5 * 60000;
-  AGENT_STOP_TERMINAL_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
   CONNECTION_CLOSE_REQUEST_TTL_MS = 10 * 60000;
   ENHANCER_TERMINAL_JOB_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 });
@@ -29314,7 +29355,7 @@ async function waitForHarnessSessionId(agentMgr, chatroomId, role, signal) {
   return null;
 }
 async function ensureColdSessionBeforeNativeInject(task, deps) {
-  if (!taskRequestsNativeColdSession({
+  if (!taskRequestsNativeColdSession2({
     content: task.taskContent ?? "",
     taskEnvelope: task.taskEnvelope,
     startInNewSession: task.startInNewSession
@@ -29460,7 +29501,7 @@ function claimPendingTaskIfNeeded(task, deps) {
   });
 }
 function resolveHarnessSessionPolicy(task, initialHarnessSessionId) {
-  if (!taskRequestsNativeColdSession({
+  if (!taskRequestsNativeColdSession2({
     content: task.taskContent ?? "",
     taskEnvelope: task.taskEnvelope,
     startInNewSession: task.startInNewSession
@@ -29674,7 +29715,7 @@ class AgentWorkManager {
     });
     this.deliveryTaskService = {
       isNativeHarness,
-      snapshotRequestsNativeColdSession,
+      taskRequestsNativeColdSession,
       explainNativeDeliveryBlock,
       releaseTaskAfterTurnFailure: deps.taskService.releaseTaskAfterTurnFailure,
       loadAssignedTaskForAction: deps.taskService.loadAssignedTaskForAction,
@@ -29706,7 +29747,7 @@ class AgentWorkManager {
   }
   async handleAgentTurnEnded(event) {
     const completion = event.completion;
-    if (completion && completion.status !== "completed") {
+    if (completion.status !== "completed") {
       const activeTask = this.deps.agentTaskState.get({
         chatroomId: event.chatroomId,
         role: event.role
@@ -29754,6 +29795,16 @@ class AgentWorkManager {
       return { kind: "release-slot" };
     }
     this.deps.agentTaskState.clear({ chatroomId: event.chatroomId, role: event.role });
+    try {
+      await this.deps.lifecycleOutbox.enqueue(buildAgentStatusFact({
+        chatroomId: event.chatroomId,
+        role: event.role,
+        status: "waiting"
+      }));
+    } catch (error) {
+      console.error(`[NativeDelivery:turn-ended-outbox-error] chatroom=${event.chatroomId} role=${event.role} error=${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      return { kind: "hold-slot", reason: "turn-ended-outbox-enqueue-failed" };
+    }
     this.scheduleRoleDelivery(event.chatroomId, event.role);
     return { kind: "release-slot" };
   }
@@ -29777,7 +29828,7 @@ class AgentWorkManager {
   }
   async handleTaskServiceNotification(notification) {
     if (notification.kind === "bootstrap") {
-      await this.requestReconcileForSnapshots(notification.snapshots, "bootstrap");
+      await this.requestReconcileForTasks(notification.tasks, "bootstrap");
       return;
     }
     if (notification.event.eventType === "task_deleted" /* TaskDeleted */) {
@@ -29795,7 +29846,7 @@ class AgentWorkManager {
       return;
     this.deps.agentTaskState.clear({ chatroomId, role });
     const slot = this.deps.agentMgr.getSlot(chatroomId, role);
-    if (!slot || slot.state === "idle" || slot.state === "stopping")
+    if (!slot || slot.state === AGENT_SLOT_STATE.IDLE || slot.state === AGENT_SLOT_STATE.STOPPING)
       return;
     try {
       await this.deps.runSerializedForAgent({ chatroomId, role }, { timeoutMs: 120000 }, (ops, context5) => ops.stopAgent({
@@ -29825,14 +29876,14 @@ class AgentWorkManager {
         do {
           const source = state.pendingSource ?? params.source;
           state.pendingSource = undefined;
-          const snapshots = this.deps.taskSnapshotState.listForRole(params.chatroomId, params.role);
-          if (snapshots.length === 0) {
+          const tasks = this.deps.taskInboxState.listForRole(params.chatroomId, params.role);
+          if (tasks.length === 0) {
             logNativeDeliveryDecision(source, params.role, params.chatroomId, "idle", undefined, {
               reason: "no_deliverable_task",
               attemptId: `${Date.now()}-${params.chatroomId}-${params.role}`
             });
           }
-          await this.reconcileRole(source, snapshots, params.onTaskDelivered);
+          await this.reconcileRole(source, tasks, params.onTaskDelivered);
         } while (state.pendingSource !== undefined);
       } finally {
         if (this.reconcileStates.get(key) === state)
@@ -29854,8 +29905,8 @@ class AgentWorkManager {
     });
     return delivered;
   }
-  async requestReconcileForSnapshots(snapshots, source) {
-    const roles = new Set(snapshots.map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
+  async requestReconcileForTasks(tasks, source) {
+    const roles = new Set(tasks.map((snapshot) => `${snapshot.chatroomId}:${snapshot.agentConfig.role.toLowerCase()}`));
     await Promise.all([...roles].map((key) => {
       const separator = key.indexOf(":");
       return this.requestReconcile({
@@ -29865,11 +29916,11 @@ class AgentWorkManager {
       });
     }));
   }
-  async reconcileRole(pass, snapshots, onTaskDelivered) {
-    if (snapshots.length === 0)
+  async reconcileRole(pass, tasks, onTaskDelivered) {
+    if (tasks.length === 0)
       return;
     await processTasksUpdate(this.deps.runtime, this.deps.effectContext, this.deps.agentMgr, this.deps.runSerializedForAgent, this.deliveryTaskService, this.deps.sessionDeps, this.deps.machineId, pass, this.deps.lifecycleOutbox, ({ chatroomId, role, taskId }) => this.deps.agentTaskState.get({ chatroomId, role })?.taskId === taskId, {
-      snapshots,
+      tasks,
       onTaskDelivered: (args2) => {
         this.recordTaskDelivered(args2);
         onTaskDelivered?.(args2);
@@ -29884,6 +29935,7 @@ var init_agent_work_manager = __esm(() => {
   init_agent();
   init_chatroom_workspace_task_inbox();
   init_esm();
+  init_agent_slot();
   init_native_cold_session_delivery();
   init_native_task_injector_logic();
   init_convex_native_task_delivery_gateway();
@@ -30291,14 +30343,12 @@ var init_agent_task_state = () => {};
 function defaultNativeTurnPhase() {
   return "idle";
 }
-function isNativeSlotIdleForDelivery(slot) {
-  if (slot?.state !== "running")
-    return false;
-  return (slot.nativeTurnPhase ?? defaultNativeTurnPhase()) === "idle";
-}
 function setNativeTurnPhase(slot, phase) {
   slot.nativeTurnPhase = phase;
 }
+var init_native_turn_phase = __esm(() => {
+  init_agent_slot();
+});
 
 // src/daemon/services/agent-process-service/infrastructure/adapters/orphan-process-tracker.ts
 import { createHash } from "node:crypto";
@@ -30441,9 +30491,6 @@ function normalizeAgentStopRole(role) {
 function buildAgentStopTargetKey(args2) {
   return `${args2.machineId}:${normalizeAgentStopRole(args2.role)}:${args2.pid}`;
 }
-function buildAgentStopRevisionKey(args2) {
-  return `${args2.stopCommandId}:${args2.targetKey}`;
-}
 
 // src/infrastructure/deps/process.ts
 function isProcessAlive(kill, pid) {
@@ -30675,9 +30722,6 @@ function createChatroomScopeBarrier() {
     }
   };
 }
-function resetChatroomScopeBarrierForTests() {
-  activeChatroomScopeDepth.clear();
-}
 function createStopAgentTargetsDeps(args2) {
   const confirmed = createStopAgentConfirmedDeps(args2.confirmedDeps);
   return {
@@ -30707,26 +30751,6 @@ async function runRoleScopedStop(args2) {
     targets
   });
 }
-function createStopAgentTargetsDepsForCommand(args2) {
-  const base = createStopAgentTargetsDeps(args2);
-  return {
-    ...base,
-    buildRevisionKey: (target) => buildAgentStopRevisionKey({ stopCommandId: args2.stopCommandId, targetKey: target.targetKey })
-  };
-}
-async function runExactTargetsStop(args2) {
-  const deps = createStopAgentTargetsDepsForCommand(args2);
-  const targets = args2.targets.map((target) => ({
-    ...target,
-    agentHarness: target.agentHarness
-  }));
-  return stopAgentTargets(deps, {
-    chatroomId: args2.chatroomId,
-    scope: { kind: "chatroom" },
-    reason: args2.reason,
-    targets
-  });
-}
 var activeChatroomScopeDepth;
 var init_execute_stop_targets_adapter = __esm(() => {
   init_stop_agent_confirmed_adapter();
@@ -30810,12 +30834,6 @@ var init_agent_lifecycle_types = __esm(() => {
   };
 });
 
-// src/daemon/domain/entities/agent-slot.ts
-function agentKey(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
-}
-var idleSlot = () => ({ state: "idle" });
-
 // src/daemon/domain/usecase/transition-agent-slot.ts
 function makeError(from, event) {
   return {
@@ -30831,7 +30849,11 @@ function transitionFromIdle(slot, event) {
     return makeResult(slot);
   }
   if (event.type === "spawn_started") {
-    return makeResult({ ...slot, state: "spawning", pendingOperationKey: event.operationKey });
+    return makeResult({
+      ...slot,
+      state: AGENT_SLOT_STATE.SPAWNING,
+      pendingOperationKey: event.operationKey
+    });
   }
   if (event.type === "process_exited") {
     return makeResult(slot);
@@ -30843,31 +30865,35 @@ function transitionFromSpawning(slot, event) {
     return makeResult({ ...slot, pendingOperationKey: event.operationKey });
   }
   if (event.type === "spawn_succeeded") {
-    return makeResult({ ...slot, state: "running", pid: event.pid });
+    return makeResult({ ...slot, state: AGENT_SLOT_STATE.RUNNING, pid: event.pid });
   }
   if (event.type === "spawn_failed" || event.type === "process_exited") {
-    return makeResult({ state: "idle" });
+    return makeResult({ state: AGENT_SLOT_STATE.IDLE });
   }
   return makeError(slot.state, event.type);
 }
 function transitionFromRunning(slot, event) {
   if (event.type === "stop_requested") {
-    return makeResult({ ...slot, state: "stopping", pendingOperationKey: event.operationKey });
+    return makeResult({
+      ...slot,
+      state: AGENT_SLOT_STATE.STOPPING,
+      pendingOperationKey: event.operationKey
+    });
   }
   if (event.type === "process_exited") {
     if (slot.pid !== undefined && slot.pid !== event.pid) {
       return { ok: false, error: { _tag: "StalePid", expected: slot.pid, got: event.pid } };
     }
-    return makeResult({ state: "idle" });
+    return makeResult({ state: AGENT_SLOT_STATE.IDLE });
   }
   if (event.type === "stale_process_detected") {
-    return makeResult({ state: "idle" });
+    return makeResult({ state: AGENT_SLOT_STATE.IDLE });
   }
   return makeError(slot.state, event.type);
 }
 function transitionFromStopping(slot, event) {
   if (event.type === "stop_completed") {
-    return makeResult({ state: "idle" });
+    return makeResult({ state: AGENT_SLOT_STATE.IDLE });
   }
   if (event.type === "process_exited") {
     return { ok: false, error: { _tag: "IgnoredDuplicateExit" } };
@@ -30876,29 +30902,34 @@ function transitionFromStopping(slot, event) {
 }
 function transitionSlot(slot, event) {
   switch (slot.state) {
-    case "idle":
+    case AGENT_SLOT_STATE.IDLE:
       return transitionFromIdle(slot, event);
-    case "spawning":
+    case AGENT_SLOT_STATE.SPAWNING:
       return transitionFromSpawning(slot, event);
-    case "running":
+    case AGENT_SLOT_STATE.RUNNING:
       return transitionFromRunning(slot, event);
-    case "stopping":
+    case AGENT_SLOT_STATE.STOPPING:
       return transitionFromStopping(slot, event);
   }
 }
 function shouldIgnoreProcessExit(slot, exitPid) {
-  if (slot.state === "stopping")
+  if (slot.state === AGENT_SLOT_STATE.STOPPING)
     return true;
   if (slot.pid !== undefined && slot.pid !== exitPid)
     return true;
   return false;
 }
+var init_transition_agent_slot = __esm(() => {
+  init_agent_slot();
+});
 
 // src/infrastructure/services/agent-lifecycle/agent-lifecycle-service.ts
 var AgentLifecycleServiceLive;
 var init_agent_lifecycle_service = __esm(() => {
   init_esm();
   init_agent_lifecycle_types();
+  init_agent_slot();
+  init_transition_agent_slot();
   AgentLifecycleServiceLive = exports_Layer.effect(AgentLifecycleService, exports_Effect.gen(function* () {
     const ports = yield* AgentLifecyclePorts;
     const slotsRef = yield* exports_Ref.make(new Map);
@@ -30955,18 +30986,16 @@ var init_agent_lifecycle_service = __esm(() => {
         const updatedSlot = { ...slot, harnessSessionId: spawnHandle.harnessSessionId };
         yield* setSlotInRef(key, updatedSlot);
       }
-      return { success: true, pid: slot.pid };
+      return { success: true, pid: slot.pid, disposition: AGENT_START_DISPOSITION.STARTED };
     });
     const ensureRunning = (opts) => exports_Effect.gen(function* () {
       const key = agentKey(opts.chatroomId, opts.role);
       const currentSlot = yield* getSlotFromRef(key);
-      if (currentSlot && currentSlot.state !== "idle") {
-        if (opts.lifecycleRevision !== undefined && currentSlot.authorizedLifecycleRevision !== opts.lifecycleRevision) {
-          return { success: false, error: "stale_revision" };
-        }
+      if (currentSlot && isAgentSlotActive(currentSlot)) {
         return {
           success: true,
-          pid: currentSlot.pid
+          pid: currentSlot.pid,
+          disposition: isAgentSlotStarted(currentSlot) ? AGENT_START_DISPOSITION.ALREADY_STARTED : AGENT_START_DISPOSITION.START_IN_PROGRESS
         };
       }
       const allowResult = ports.spawn.shouldAllowSpawn(opts.chatroomId, opts.reason);
@@ -31039,7 +31068,7 @@ var init_agent_lifecycle_service = __esm(() => {
     const listActive = () => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => {
       const results = [];
       for (const [key, slot] of map18) {
-        if (slot.state !== "idle") {
+        if (isAgentSlotActive(slot)) {
           const [chatroomId, role] = key.split(":");
           results.push({ chatroomId, role, slot });
         }
@@ -31468,7 +31497,7 @@ class AgentProcessManager {
     return () => this.agentSessionLostHandlers.delete(handler);
   }
   clearSlotRuntimeState(slot) {
-    slot.state = "idle";
+    slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pid = undefined;
     slot.harness = undefined;
     slot.harnessSessionId = undefined;
@@ -31527,22 +31556,27 @@ class AgentProcessManager {
     } else if (slot.stopRequested) {
       return { success: false, error: "stop_requested" };
     }
-    if (slot.state !== "idle" && opts.lifecycleRevision !== undefined && slot.authorizedLifecycleRevision !== opts.lifecycleRevision) {
-      return { success: false, error: "stale_revision" };
-    }
-    if (slot.state === "running" && slot.pid && !isProcessAlive(this.deps.processes.kill, slot.pid)) {
+    if (slot.state === AGENT_SLOT_STATE.RUNNING && slot.pid && !isProcessAlive(this.deps.processes.kill, slot.pid)) {
       this.clearSlotRuntimeState(slot);
     }
-    if (slot.state === "stopping" && (slot.stoppingSince === undefined || this.deps.clock.now() - slot.stoppingSince >= STOPPING_TIMEOUT_MS)) {
+    if (slot.state === AGENT_SLOT_STATE.STOPPING && (slot.stoppingSince === undefined || this.deps.clock.now() - slot.stoppingSince >= STOPPING_TIMEOUT_MS)) {
       await this.forceClearStuckStoppingSlot(key, slot, opts.chatroomId, opts.role, "daemon.stop_timeout");
     }
     if (slot.pendingOperation) {
-      if (slot.state === "stopping") {
+      if (slot.state === AGENT_SLOT_STATE.STOPPING) {
         await slot.pendingOperation;
       } else {
         return slot.pendingOperation;
       }
     }
+    const pid = slot.pid;
+    if (isAgentSlotStarted(slot) && pid !== undefined && isProcessAlive(this.deps.processes.kill, pid)) {
+      return {
+        success: true,
+        pid,
+        disposition: AGENT_START_DISPOSITION.ALREADY_STARTED
+      };
+    }
     const operation = this.executeEnsureRunning(key, slot, opts);
     slot.pendingOperation = operation;
     return operation;
@@ -31627,7 +31661,7 @@ class AgentProcessManager {
   }
   bindStopTarget(args2) {
     const slot = this.slots.get(agentKey2(args2.chatroomId, args2.role));
-    if (!slot || slot.pid !== args2.pid || slot.state !== "stopping")
+    if (!slot || slot.pid !== args2.pid || slot.state !== AGENT_SLOT_STATE.STOPPING)
       return;
     slot.stopCommandId = args2.stopCommandId;
     slot.stopTargetKey = args2.targetKey;
@@ -31635,12 +31669,12 @@ class AgentProcessManager {
   async withScopedRoleStop(opts, fn2) {
     const key = agentKey2(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
-    if (!slot || !slot.pid || slot.state === "idle")
+    if (!slot || !slot.pid || slot.state === AGENT_SLOT_STATE.IDLE)
       return { ok: false, reason: "no_slot" };
-    if (slot.state === "stopping" || slot.pendingOperation)
+    if (slot.state === AGENT_SLOT_STATE.STOPPING || slot.pendingOperation)
       return { ok: false, reason: "concurrent" };
     this.markStopIntent(opts.chatroomId, opts.role, opts.reason, slot.pid);
-    slot.state = "stopping";
+    slot.state = AGENT_SLOT_STATE.STOPPING;
     slot.stoppingSince = this.deps.clock.now();
     try {
       const value = await fn2();
@@ -31648,26 +31682,26 @@ class AgentProcessManager {
       await this.clearAgentPidQuietly(opts.chatroomId, opts.role);
       return { ok: true, value };
     } catch (error) {
-      slot.state = "running";
+      slot.state = AGENT_SLOT_STATE.RUNNING;
       throw error;
     }
   }
   async handleStopEarlyReturns(slot, opts, key) {
-    if (!slot || slot.state === "idle") {
+    if (!slot || slot.state === AGENT_SLOT_STATE.IDLE) {
       await this.killAndRecordForIdleSlot(slot, opts);
       return { success: true };
     }
-    if (slot.state === "stopping" && slot.pendingOperation) {
+    if (slot.state === AGENT_SLOT_STATE.STOPPING && slot.pendingOperation) {
       await slot.pendingOperation;
       return { success: true };
     }
     const pid = slot.pid;
     if (!pid) {
-      slot.state = "idle";
+      slot.state = AGENT_SLOT_STATE.IDLE;
       slot.pendingOperation = undefined;
       return { success: true };
     }
-    slot.state = "stopping";
+    slot.state = AGENT_SLOT_STATE.STOPPING;
     const stopGeneration = slot.stopGeneration ?? 0;
     slot.stoppingSince = this.deps.clock.now();
     const operation = this.doStop(key, slot, pid, opts, stopGeneration);
@@ -31696,13 +31730,13 @@ class AgentProcessManager {
   }
   async runHandleAgentEnd(opts) {
     const slot = this.slots.get(agentKey2(opts.chatroomId, opts.role));
-    if (!slot || slot.pid !== opts.pid || slot.harness !== opts.harness || slot.state !== "running") {
+    if (!slot || slot.pid !== opts.pid || slot.harness !== opts.harness || slot.state !== AGENT_SLOT_STATE.RUNNING) {
       console.log(`[AgentProcessManager] Ignoring stale agent_end: role=${opts.role} callbackPid=${opts.pid} currentPid=${slot?.pid ?? "none"} currentState=${slot?.state ?? "none"}`);
       return;
     }
     const capabilities = getHarnessCapabilities(opts.harness);
     this.updateSlotsMirror(opts.chatroomId, opts.role, {
-      state: slot?.state ?? "idle",
+      state: slot?.state ?? AGENT_SLOT_STATE.IDLE,
       pid: slot?.pid,
       harness: slot?.harness,
       harnessSessionId: slot?.harnessSessionId,
@@ -31767,7 +31801,7 @@ class AgentProcessManager {
   async handleExit(opts) {
     const key = agentKey2(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
-    if (!slot || slot.pid !== opts.pid || slot.state === "stopping") {
+    if (!slot || slot.pid !== opts.pid || slot.state === AGENT_SLOT_STATE.STOPPING) {
       return;
     }
     if (slot.stopRequested && slot.expectedStopPid === opts.pid) {
@@ -31812,7 +31846,7 @@ class AgentProcessManager {
     };
   }
   resetSlotAfterExit(slot) {
-    slot.state = "idle";
+    slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
@@ -31857,15 +31891,15 @@ class AgentProcessManager {
       model: slot.model ?? "",
       message: classification2.message
     });
-    this.deps.backend.mutation(api.daemon.agentEvents.agentProviderUnavailable, {
-      sessionId: this.deps.sessionId,
-      machineId: this.deps.machineId,
+    this.deps.lifecycleOutbox.enqueue(buildAgentStatusFact({
       chatroomId,
       role,
-      reason: classification2.reason,
-      model: slot.model ?? "",
-      message: classification2.message
-    }).catch(() => {});
+      status: "error",
+      errorSource: "runtime",
+      errorCode: classification2.reason,
+      errorMessage: `${classification2.message}${slot.model ? ` (model: ${slot.model})` : ""}`,
+      emittedAt: this.deps.clock.now()
+    })).catch(() => {});
   }
   getSlot(chatroomId, role) {
     return this.getSlotFromMirror(chatroomId, role);
@@ -31873,7 +31907,7 @@ class AgentProcessManager {
   listActive() {
     const result = [];
     for (const [key, slot] of this.slots) {
-      if (slot.state === "running" || slot.state === "spawning") {
+      if (slot.state === AGENT_SLOT_STATE.RUNNING || slot.state === AGENT_SLOT_STATE.SPAWNING) {
         const [chatroomId, role] = key.split(":");
         result.push({ chatroomId, role, slot });
       }
@@ -31891,7 +31925,7 @@ class AgentProcessManager {
   async clearStuckStoppingSlot(chatroomId, role, options) {
     const key = agentKey2(chatroomId, role);
     const slot = this.slots.get(key);
-    if (!slot || slot.state !== "stopping") {
+    if (!slot || slot.state !== AGENT_SLOT_STATE.STOPPING) {
       return false;
     }
     const elapsed3 = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
@@ -31967,7 +32001,7 @@ class AgentProcessManager {
   getOrCreateSlot(key) {
     let slot = this.slots.get(key);
     if (!slot) {
-      slot = { state: "idle" };
+      slot = { state: AGENT_SLOT_STATE.IDLE };
       this.slots.set(key, slot);
     }
     return slot;
@@ -31996,9 +32030,9 @@ class AgentProcessManager {
   }
   async killInMemorySlotIfAlive(key, chatroomId, role) {
     const slot = this.slots.get(key);
-    if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === "running" || slot.state === "spawning")) {
+    if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === AGENT_SLOT_STATE.RUNNING || slot.state === AGENT_SLOT_STATE.SPAWNING)) {
       const pid = slot.pid;
-      slot.state = "stopping";
+      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" }, stopGeneration);
@@ -32022,7 +32056,7 @@ class AgentProcessManager {
     }
     const key = agentKey2(chatroomId, role);
     const currentSlot = this.slots.get(key);
-    if (currentSlot?.pid === pid && currentSlot.state !== "idle") {
+    if (currentSlot?.pid === pid && currentSlot.state !== AGENT_SLOT_STATE.IDLE) {
       return;
     }
     await this.stopPersistedProcess(pid, harness);
@@ -32121,7 +32155,7 @@ class AgentProcessManager {
     }
   }
   resetSlotIdle(slot) {
-    slot.state = "idle";
+    slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pendingOperation = undefined;
   }
   checkRateLimitGate(opts, slot) {
@@ -32214,7 +32248,7 @@ class AgentProcessManager {
     return { ok: true, spawnResult };
   }
   assignRunningSlotState(key, slot, opts, spawnResult, wantResume, pid) {
-    slot.state = "running";
+    slot.state = AGENT_SLOT_STATE.RUNNING;
     slot.pid = pid;
     slot.harness = opts.agentHarness;
     slot.harnessSessionId = spawnResult.harnessSessionId;
@@ -32242,12 +32276,6 @@ class AgentProcessManager {
     }).catch((err) => {
       console.log(`   ⚠️  Failed to record agent.started event: ${err.message}`);
     });
-    const lifecycleRevision = slot.authorizedLifecycleRevision ?? opts.lifecycleRevision;
-    if (lifecycleRevision === undefined) {
-      this.deps.processes.kill(pid, "SIGTERM");
-      this.resetSlotIdle(slot);
-      return Promise.resolve();
-    }
     const emittedAt = this.deps.clock.now();
     return this.deps.lifecycleOutbox.enqueue({
       kind: "spawned",
@@ -32263,14 +32291,9 @@ class AgentProcessManager {
         pid,
         emittedAt
       }),
-      emittedAt,
-      lifecycleRevision
-    }).then((result) => {
-      if (result.rejectionReason) {
-        console.log(`   ⚠️  Spawn rejected by backend: ${result.rejectionReason}`);
-        this.deps.processes.kill(pid, "SIGTERM");
-        this.resetSlotIdle(slot);
-      }
+      emittedAt
+    }).then(() => {
+      return;
     }).catch((err) => console.log(`   ⚠️  Failed to enqueue agent spawned lifecycle fact: ${err.message}`));
   }
   registerSpawnCallbacks(slot, opts, spawnResult, pid) {
@@ -32397,20 +32420,18 @@ class AgentProcessManager {
     });
   }
   async doEnsureRunning(key, slot, opts) {
-    slot.state = "spawning";
+    slot.state = AGENT_SLOT_STATE.SPAWNING;
     const authorization = await this.deps.backend.mutation(api.machines.authorizeAgentStart, {
       sessionId: this.deps.sessionId,
       machineId: this.deps.machineId,
       chatroomId: opts.chatroomId,
       role: opts.role,
-      lifecycleRevision: opts.lifecycleRevision,
       taskId: opts.taskId
     });
     if (!authorization.allowed) {
       this.resetSlotIdle(slot);
       return { success: false, error: authorization.reason };
     }
-    slot.authorizedLifecycleRevision = authorization.lifecycleRevision;
     const wantResume = opts.wantResume;
     console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${wantResume} reason=${opts.reason}`);
     try {
@@ -32427,7 +32448,11 @@ class AgentProcessManager {
       if (!spawn2.ok)
         return spawn2.result;
       await this.finalizeRunningSlot(key, slot, opts, spawn2.spawnResult, wantResume);
-      return { success: true, pid: spawn2.spawnResult.pid };
+      return {
+        success: true,
+        pid: spawn2.spawnResult.pid,
+        disposition: AGENT_START_DISPOSITION.STARTED
+      };
     } catch (e) {
       this.resetSlotIdle(slot);
       return { success: false, error: `Unexpected error: ${e.message}` };
@@ -32461,7 +32486,7 @@ class AgentProcessManager {
     }
   }
   resetSlotAfterStop(slot) {
-    slot.state = "idle";
+    slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
@@ -32470,8 +32495,6 @@ class AgentProcessManager {
   async forceClearStuckStoppingSlot(key, slot, chatroomId, role, reason, clearStopIntent = false) {
     const pid = slot.pid;
     const harness = slot.harness;
-    const stopCommandId = slot.stopCommandId;
-    const stopTargetKey = slot.stopTargetKey;
     const durationMs = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
     this.bumpStopGeneration(slot);
     this.clearSlotRuntimeState(slot);
@@ -32505,32 +32528,6 @@ class AgentProcessManager {
       };
       this.recordAgentExit(role, exitArgs, "Failed to record stop-timeout exit");
     }
-    if (pid && stopCommandId && stopTargetKey) {
-      try {
-        await this.deps.backend.mutation(api.agentStops.reportTargetOutcome, {
-          sessionId: this.deps.sessionId,
-          stopCommandId,
-          chatroomId,
-          machineId: this.deps.machineId,
-          targetKey: stopTargetKey,
-          role,
-          pid,
-          status: "failed",
-          outcome: "failed",
-          termination: "forced",
-          errorMessage: "Daemon force-cleared a timed-out stop operation"
-        });
-        await this.deps.backend.mutation(api.agentStops.completeMachineExecution, {
-          sessionId: this.deps.sessionId,
-          stopCommandId,
-          machineId: this.deps.machineId,
-          status: "failed",
-          errorMessage: "Daemon force-cleared a timed-out stop operation"
-        });
-      } catch (error) {
-        console.log(`   ⚠️  Failed to finalize timed-out stop for ${role}@${chatroomId}: ${error.message}`);
-      }
-    }
     await this.clearAgentPidQuietly(chatroomId, role);
   }
   async doStop(key, slot, pid, opts, stopGeneration) {
@@ -32590,10 +32587,12 @@ var init_agent_process_manager = __esm(() => {
   init_api3();
   init_agent_lifecycle_runtime();
   init_agent_lifecycle_types();
+  init_agent_slot();
   init_agent_stop();
   init_spawn_policy();
   init_classify_provider_error();
   init_native_spawn_presence();
+  init_native_turn_phase();
 });
 
 // src/daemon/services/agent-process-service/infrastructure/harness-activity-emitter.ts
@@ -32618,10 +32617,7 @@ function createHarnessActivityEmitter() {
     }
   };
 }
-var HARNESS_ACTIVITY_KINDS;
-var init_harness_activity_emitter = __esm(() => {
-  HARNESS_ACTIVITY_KINDS = ["transport", "progress", "waiting", "failure"];
-});
+var init_harness_activity_emitter = () => {};
 
 // src/daemon/services/agent-process-service/index.ts
 var init_agent_process_service2 = __esm(() => {
@@ -32629,6 +32625,7 @@ var init_agent_process_service2 = __esm(() => {
   init_agent_task_state();
   init_agent_process_command_bus();
   init_service();
+  init_native_turn_phase();
   init_agent_process_manager();
   init_execute_stop_targets_adapter();
   init_harness_activity_emitter();
@@ -32643,58 +32640,58 @@ var init_agent_process_contracts = __esm(() => {
   init_harness_activity_emitter();
 });
 
-// src/daemon/infrastructure/inbox/task-state-manager.ts
-function snapshotKey(taskId, role) {
+// src/daemon/infrastructure/inbox/task-inbox-state.ts
+function taskKey(taskId, role) {
   return `${taskId}:${role.toLowerCase()}`;
 }
-function isStaleStatusPatch(snapshot, status3, updatedAt) {
-  if (snapshot.updatedAt > updatedAt)
+function isStaleStatusPatch(current, status3, updatedAt) {
+  if (current.updatedAt > updatedAt)
     return true;
-  return snapshot.updatedAt === updatedAt && snapshot.status === "completed" && status3 !== "completed";
+  return current.updatedAt === updatedAt && current.status === "completed" && status3 !== "completed";
 }
 
-class TaskStateManager {
-  snapshots = new Map;
+class TaskInboxState {
+  tasks = new Map;
   initialized = false;
-  replace(snapshots) {
-    this.snapshots.clear();
-    this.upsert(snapshots);
+  replace(tasks) {
+    this.tasks.clear();
+    this.upsert(tasks);
     this.initialized = true;
   }
   listForRole(chatroomId, role) {
     const roleLower = role.toLowerCase();
-    return [...this.snapshots.values()].filter((snapshot) => snapshot.chatroomId === chatroomId && snapshot.agentConfig.role.toLowerCase() === roleLower);
+    return [...this.tasks.values()].filter((task) => task.chatroomId === chatroomId && task.agentConfig.role.toLowerCase() === roleLower);
   }
   isInitialized() {
     return this.initialized;
   }
   getForRole(chatroomId, role, taskId) {
-    const snapshot = this.snapshots.get(snapshotKey(taskId, role));
-    return snapshot?.chatroomId === chatroomId ? snapshot : null;
+    const task = this.tasks.get(taskKey(taskId, role));
+    return task?.chatroomId === chatroomId ? task : null;
   }
   listAll() {
-    return [...this.snapshots.values()];
+    return [...this.tasks.values()];
   }
-  upsert(snapshots) {
-    for (const snapshot of snapshots) {
-      this.snapshots.set(snapshotKey(snapshot.taskId, snapshot.agentConfig.role), snapshot);
+  upsert(tasks) {
+    for (const task of tasks) {
+      this.tasks.set(taskKey(task.taskId, task.agentConfig.role), task);
     }
   }
   remove(chatroomId, role, taskId) {
-    const key = snapshotKey(taskId, role);
-    const snapshot = this.snapshots.get(key);
-    if (!snapshot || snapshot.chatroomId !== chatroomId)
+    const key = taskKey(taskId, role);
+    const task = this.tasks.get(key);
+    if (!task || task.chatroomId !== chatroomId)
       return false;
-    return this.snapshots.delete(key);
+    return this.tasks.delete(key);
   }
   markStatus(chatroomId, role, taskId, status3, updatedAt) {
-    const key = snapshotKey(taskId, role);
-    const snapshot = this.snapshots.get(key);
-    if (!snapshot || snapshot.chatroomId !== chatroomId)
+    const key = taskKey(taskId, role);
+    const task = this.tasks.get(key);
+    if (!task || task.chatroomId !== chatroomId)
       return false;
-    if (isStaleStatusPatch(snapshot, status3, updatedAt))
+    if (isStaleStatusPatch(task, status3, updatedAt))
       return false;
-    this.snapshots.set(key, { ...snapshot, status: status3, updatedAt });
+    this.tasks.set(key, { ...task, status: status3, updatedAt });
     return true;
   }
 }
@@ -32702,19 +32699,25 @@ class TaskStateManager {
 // src/daemon/services/task-service/service/task-service.ts
 function createTaskService(deps) {
   const gateway = createConvexNativeTaskDeliveryGateway(deps.backend);
-  const taskSnapshotState = new TaskStateManager;
+  const taskInboxState = new TaskInboxState;
   const listeners = new Set;
-  let inboxPollTimer;
-  let inboxPollInFlight = false;
+  let stopInboxWatch;
+  let inboxStopped = false;
+  const pendingEvents = new Map;
+  const scheduledEventIds = new Set;
+  const deliveredEventIds = new Set;
+  const deliveryRetryTimers = new Map;
+  const acknowledgementRetryTimers = new Map;
+  const taskChains = new Map;
   const notify = async (notification) => {
     await Promise.all([...listeners].map((listener) => Promise.resolve(listener(notification))));
   };
   const applyInboxEvent = (event) => {
     if (event.eventType === "task_deleted" /* TaskDeleted */ || event.task.status === "completed") {
-      taskSnapshotState.remove(event.chatroomId, event.role, event.taskId);
+      taskInboxState.remove(event.chatroomId, event.role, event.taskId);
       return true;
     }
-    taskSnapshotState.upsert([
+    taskInboxState.upsert([
       {
         taskId: event.task.taskId,
         chatroomId: event.task.chatroomId,
@@ -32732,45 +32735,130 @@ function createTaskService(deps) {
     ]);
     return true;
   };
-  const pollTaskInbox = async () => {
-    if (inboxPollInFlight)
+  const taskKey2 = (event) => `${event.chatroomId}:${event.role.toLowerCase()}:${event.taskId}`;
+  const clearRetryTimer = (timers, eventId) => {
+    const timer = timers.get(eventId);
+    if (timer)
+      clearTimeout(timer);
+    timers.delete(eventId);
+  };
+  const retryDelivery = (eventId) => {
+    if (inboxStopped || deliveryRetryTimers.has(eventId) || !pendingEvents.has(eventId))
       return;
-    inboxPollInFlight = true;
+    const timer = setTimeout(() => {
+      deliveryRetryTimers.delete(eventId);
+      const event = pendingEvents.get(eventId);
+      if (event)
+        scheduleEvent(event);
+    }, TASK_INBOX_RETRY_DELAY_MS);
+    deliveryRetryTimers.set(eventId, timer);
+    timer.unref?.();
+  };
+  const retryAcknowledgement = (eventId) => {
+    if (inboxStopped || acknowledgementRetryTimers.has(eventId) || !pendingEvents.has(eventId)) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      acknowledgementRetryTimers.delete(eventId);
+      const event = pendingEvents.get(eventId);
+      if (event)
+        acknowledgeEvent(event);
+    }, TASK_INBOX_RETRY_DELAY_MS);
+    acknowledgementRetryTimers.set(eventId, timer);
+    timer.unref?.();
+  };
+  const acknowledgeEvent = async (event) => {
     try {
-      const events = await gateway.listPendingTaskInboxEvents({
+      await gateway.markTaskInboxEventProcessed({
         sessionId: deps.sessionId,
-        machineId: deps.machineId
+        machineId: deps.machineId,
+        eventId: event.eventId
       });
-      for (const event of events) {
+    } catch (error) {
+      console.warn("[TaskService] task inbox acknowledgement failed:", error);
+      retryAcknowledgement(event.eventId);
+    }
+  };
+  const scheduleEvent = (event) => {
+    if (inboxStopped || deliveredEventIds.has(event.eventId) || scheduledEventIds.has(event.eventId)) {
+      return Promise.resolve();
+    }
+    scheduledEventIds.add(event.eventId);
+    const previous = taskChains.get(taskKey2(event)) ?? Promise.resolve();
+    const current = previous.catch(() => {
+      return;
+    }).then(async () => {
+      try {
         if (!applyInboxEvent(event))
-          continue;
+          return;
         await notify({ kind: "inbox-event", event });
-        await gateway.markTaskInboxEventProcessed({
-          sessionId: deps.sessionId,
-          machineId: deps.machineId,
-          eventId: event.eventId
-        });
+        deliveredEventIds.add(event.eventId);
+      } catch (error) {
+        console.warn("[TaskService] task inbox delivery failed:", error);
+        retryDelivery(event.eventId);
+        return;
+      } finally {
+        scheduledEventIds.delete(event.eventId);
+      }
+      await acknowledgeEvent(event);
+    });
+    taskChains.set(taskKey2(event), current);
+    current.finally(() => {
+      if (taskChains.get(taskKey2(event)) === current)
+        taskChains.delete(taskKey2(event));
+    });
+    return current;
+  };
+  const reconcilePendingEvents = (events) => {
+    const nextIds = new Set(events.map((event) => event.eventId));
+    for (const eventId of pendingEvents.keys()) {
+      if (!nextIds.has(eventId)) {
+        pendingEvents.delete(eventId);
+        deliveredEventIds.delete(eventId);
+        clearRetryTimer(deliveryRetryTimers, eventId);
+        clearRetryTimer(acknowledgementRetryTimers, eventId);
       }
-    } catch (error) {
-      console.warn("[TaskService] task inbox poll failed:", error);
-    } finally {
-      inboxPollInFlight = false;
     }
+    return Promise.all(events.map((event) => {
+      pendingEvents.set(event.eventId, event);
+      return scheduleEvent(event);
+    })).then(() => {
+      return;
+    });
   };
   const service4 = {
-    startTaskInbox: async () => {
-      await pollTaskInbox();
-      inboxPollTimer ??= setInterval(() => void pollTaskInbox(), 1000);
-      inboxPollTimer.unref?.();
+    startTaskInbox: async (wsClient2) => {
+      inboxStopped = false;
+      if (wsClient2 && !stopInboxWatch) {
+        stopInboxWatch = wsClient2.onUpdate(api.chatroomWorkspaceTaskInbox.listPending, { sessionId: deps.sessionId, machineId: deps.machineId }, (rows) => {
+          reconcilePendingEvents(mapPendingTaskInboxRows(rows));
+        }, (error) => console.warn(`[daemon] task-inbox watch error: ${String(error)}`));
+      } else if (!wsClient2) {
+        const events = await gateway.listPendingTaskInboxEvents({
+          sessionId: deps.sessionId,
+          machineId: deps.machineId
+        });
+        await reconcilePendingEvents(events);
+      }
     },
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
     stopTaskInbox: () => {
-      if (inboxPollTimer)
-        clearInterval(inboxPollTimer);
-      inboxPollTimer = undefined;
+      inboxStopped = true;
+      stopInboxWatch?.();
+      stopInboxWatch = undefined;
+      pendingEvents.clear();
+      scheduledEventIds.clear();
+      deliveredEventIds.clear();
+      for (const timer of deliveryRetryTimers.values())
+        clearTimeout(timer);
+      deliveryRetryTimers.clear();
+      for (const timer of acknowledgementRetryTimers.values())
+        clearTimeout(timer);
+      acknowledgementRetryTimers.clear();
+      taskChains.clear();
     },
     listPendingTaskInboxEvents: () => gateway.listPendingTaskInboxEvents({
       sessionId: deps.sessionId,
@@ -32781,9 +32869,9 @@ function createTaskService(deps) {
       machineId: deps.machineId,
       eventId
     }),
-    listTasksForRole: (chatroomId, role) => taskSnapshotState.listForRole(chatroomId, role),
-    listAllTasks: () => taskSnapshotState.listAll(),
-    taskSnapshotState,
+    listTasksForRole: (chatroomId, role) => taskInboxState.listForRole(chatroomId, role),
+    listAllTasks: () => taskInboxState.listAll(),
+    taskInboxState,
     releaseTaskAfterTurnFailure: async (args2) => {
       const result = await gateway.releaseTaskAfterTurnFailure({
         sessionId: deps.sessionId,
@@ -32791,7 +32879,7 @@ function createTaskService(deps) {
         role: args2.role,
         taskId: args2.taskId
       });
-      taskSnapshotState.markStatus(args2.chatroomId, args2.role, args2.taskId, result.status, result.updatedAt);
+      taskInboxState.markStatus(args2.chatroomId, args2.role, args2.taskId, result.status, result.updatedAt);
       return result;
     },
     loadAssignedTaskForAction: async ({ chatroomId, role, taskId }) => {
@@ -32806,8 +32894,10 @@ function createTaskService(deps) {
   };
   return service4;
 }
+var TASK_INBOX_RETRY_DELAY_MS = 1000;
 var init_task_service = __esm(() => {
   init_chatroom_workspace_task_inbox();
+  init_api3();
   init_convex_native_task_delivery_gateway();
 });
 
@@ -32824,55 +32914,6 @@ var init_task_service2 = __esm(() => {
 });
 
 // src/daemon/services/service-interfaces.ts
-var exports_service_interfaces = {};
-__export(exports_service_interfaces, {
-  untrackChildPid: () => untrackChildPid,
-  trackChildPid: () => trackChildPid,
-  snapshotRequestsNativeColdSession: () => snapshotRequestsNativeColdSession,
-  shouldDeliverNativeTask: () => shouldDeliverNativeTask,
-  setNativeTurnPhase: () => setNativeTurnPhase,
-  runRoleScopedStop: () => runRoleScopedStop,
-  runNativeInjectionEffect: () => runNativeInjectionEffect,
-  runExactTargetsStop: () => runExactTargetsStop,
-  runConfirmedStop: () => runConfirmedStop,
-  resetRoleDeliveryState: () => resetRoleDeliveryState,
-  resetChatroomScopeBarrierForTests: () => resetChatroomScopeBarrierForTests,
-  reapOrphanedProcessGroupsEffect: () => reapOrphanedProcessGroupsEffect,
-  reapOrphanedProcessGroups: () => reapOrphanedProcessGroups,
-  isNativeSlotIdleForDelivery: () => isNativeSlotIdleForDelivery,
-  isNativeHarness: () => isNativeHarness,
-  isDeliverableNativeTaskStatus: () => isDeliverableNativeTaskStatus,
-  isChatroomStopScopeActive: () => isChatroomStopScopeActive,
-  isAgentReadyForNativeDelivery: () => isAgentReadyForNativeDelivery,
-  getChildPidsFilePath: () => getChildPidsFilePath,
-  forceKillAllTrackedProcessGroupsEffect: () => forceKillAllTrackedProcessGroupsEffect,
-  forceKillAllTrackedProcessGroups: () => forceKillAllTrackedProcessGroups,
-  explainNativeDeliveryBlock: () => explainNativeDeliveryBlock,
-  explainAgentReadyForNativeDeliveryBlock: () => explainAgentReadyForNativeDeliveryBlock,
-  defaultNativeTurnPhase: () => defaultNativeTurnPhase,
-  createTaskService: () => createTaskService,
-  createStopAgentTargetsDepsForCommand: () => createStopAgentTargetsDepsForCommand,
-  createStopAgentTargetsDeps: () => createStopAgentTargetsDeps,
-  createStopAgentConfirmedDeps: () => createStopAgentConfirmedDeps,
-  createHarnessActivityEmitter: () => createHarnessActivityEmitter,
-  createDaemonAuditPort: () => createDaemonAuditPort,
-  createConvexNativeTaskDeliveryGateway: () => createConvexNativeTaskDeliveryGateway,
-  createChatroomScopeBarrier: () => createChatroomScopeBarrier,
-  createAgentTaskStateService: () => createAgentTaskStateService,
-  createAgentProcessService: () => createAgentProcessService,
-  createAgentProcessManagerService: () => createAgentProcessManagerService,
-  createAgentProcessCommandBus: () => createAgentProcessCommandBus,
-  clearTrackedPidsEffect: () => clearTrackedPidsEffect,
-  clearTrackedPids: () => clearTrackedPids,
-  buildStopTargetDescriptor: () => buildStopTargetDescriptor,
-  buildNativeInjectionPrompt: () => buildNativeInjectionPrompt,
-  STOPPING_TIMEOUT_MS: () => STOPPING_TIMEOUT_MS,
-  InMemoryActiveTaskStateStore: () => InMemoryActiveTaskStateStore,
-  HARNESS_ACTIVITY_KINDS: () => HARNESS_ACTIVITY_KINDS,
-  DefaultAgentTaskStateService: () => DefaultAgentTaskStateService,
-  AgentWorkManager: () => AgentWorkManager,
-  AgentProcessManager: () => AgentProcessManager
-});
 var init_service_interfaces = __esm(() => {
   init_task_service2();
   init_agent_process_service2();
@@ -83879,7 +83920,7 @@ async function registerAgent(chatroomId, options, deps) {
 var registerAgentEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
   const machine = yield* RegisterAgentMachineService;
-  const { role, type, allowTypeChange } = options;
+  const { role, type } = options;
   const sessionId = yield* requireSessionIdEffect((a) => ({
     _tag: "NotAuthenticated",
     convexUrl: a.convexUrl,
@@ -83911,27 +83952,12 @@ var registerAgentEffect = (chatroomId, options) => exports_Effect.gen(function*
       return yield* exports_Effect.fail({ _tag: "MachineNotRegistered" });
     }
     const config2 = yield* machine.loadMachineConfig();
-    yield* backend2.mutation(api.machines.recordRemoteAgentRegistered, {
-      sessionId,
-      chatroomId,
-      role,
-      machineId
-    }).pipe(exports_Effect.catchAll(() => exports_Effect.succeed(undefined)));
     yield* exports_Effect.sync(() => {
       console.log(`✅ Registered as remote agent for role "${role}"`);
       console.log(`   Machine: ${config2?.hostname ?? "unknown"} (${machineId})`);
       console.log(`   Working directory: ${process.cwd()}`);
     });
   } else {
-    yield* backend2.mutation(api.machines.recordCustomAgentRegistered, {
-      sessionId,
-      chatroomId,
-      role,
-      allowTypeChange
-    }).pipe(exports_Effect.mapError((cause3) => ({
-      _tag: "RegisterFailed",
-      cause: cause3
-    })));
     yield* exports_Effect.sync(() => {
       console.log(`✅ Registered as custom agent for role "${role}"`);
     });
@@ -84585,11 +84611,12 @@ var getNextTaskEffect = (chatroomId, options) => exports_Effect.gen(function* ()
   const machineId = yield* exports_Effect.promise(() => getMachineId().then((id3) => id3 ?? undefined).catch(() => {
     return;
   }));
-  const teamConfigs = yield* backend2.query(api.machines.getTeamAgentConfigs, {
+  const lastSentRequest = yield* backend2.query(api.agents.getLastSentLaunchRequest, {
     sessionId,
-    chatroomId
-  }).pipe(exports_Effect.catchAll(() => exports_Effect.succeed([])));
-  const participantAgentType = teamConfigs?.find((c) => c.role.toLowerCase() === options.role.toLowerCase())?.type;
+    chatroomId,
+    role: options.role
+  }).pipe(exports_Effect.catchAll(() => exports_Effect.succeed(null)));
+  const participantAgentType = lastSentRequest?.agentType;
   yield* backend2.mutation(api.participants.join, {
     sessionId,
     chatroomId,
@@ -84674,25 +84701,39 @@ var init_get_next_task = __esm(() => {
 });
 
 // ../shared/src/domain/team-presets.ts
-function getTeamPreset(teamId) {
+function getTeamPresetId(teamId) {
   const normalized = teamId.trim().toLowerCase();
-  return normalized === "duo" || normalized === "solo" ? TEAM_PRESETS[normalized] : undefined;
+  if (normalized === "duo" || normalized === TEAM_STRUCTURE_IDS.duo)
+    return "duo";
+  if (normalized === "solo" || normalized === TEAM_STRUCTURE_IDS.solo)
+    return "solo";
+  return;
+}
+function getTeamPreset(teamId) {
+  const presetId = getTeamPresetId(teamId);
+  return presetId ? TEAM_PRESETS[presetId] : undefined;
 }
 function listTeamPresetIds() {
   return [...TEAM_PRESET_IDS];
 }
-var TEAM_PRESET_IDS, DEFAULT_TEAM_PRESET_ID = "duo", TEAM_PRESETS;
+var TEAM_PRESET_IDS, DEFAULT_TEAM_PRESET_ID = "duo", TEAM_STRUCTURE_IDS, TEAM_PRESETS;
 var init_team_presets = __esm(() => {
   init_agent_role();
   TEAM_PRESET_IDS = ["duo", "solo"];
+  TEAM_STRUCTURE_IDS = {
+    duo: "duo@1",
+    solo: "solo@1"
+  };
   TEAM_PRESETS = {
     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"],
       entryPoint: "planner"
     },
     solo: {
+      structureId: TEAM_STRUCTURE_IDS.solo,
       name: "Solo",
       description: "A single agent working independently, with optional ephemeral enhancer",
       roles: ["solo", "enhancer"],
@@ -84765,10 +84806,7 @@ async function setTeam(chatroomId, teamId, deps) {
   await d.backend.mutation(api.chatrooms.updateTeam, {
     sessionId,
     chatroomId,
-    teamId,
-    teamName: preset.name,
-    teamRoles: preset.roles,
-    teamEntryPoint: preset.entryPoint
+    teamStructureId: teamId
   });
   console.log(`✅ Team set to ${teamId} (${preset.name})`);
   console.log(`  Roles: ${preset.roles.join(", ")}`);
@@ -84815,7 +84853,7 @@ function configuredWorkingDir(config3) {
   return config3?.workingDir;
 }
 async function getConfigs(deps, sessionId, chatroomId) {
-  return await deps.backend.query(api.machines.getTeamAgentConfigs, {
+  return await deps.backend.query(api.agents.listLastSentLaunchRequests, {
     sessionId,
     chatroomId
   });
@@ -84831,7 +84869,6 @@ async function getAgentConfig(chatroomId, role, deps) {
   console.log(`  Model: ${config3.model ?? "(unset)"}`);
   console.log(`  Working directory: ${config3.workingDir ?? "(unset)"}`);
   console.log(`  Machine ID: ${config3.machineId ?? "(unset)"}`);
-  console.log(`  Desired state: ${config3.desiredState ?? "(unset)"}`);
 }
 async function setAgentConfig(chatroomId, options, deps) {
   const d = deps ?? await createDefaultDeps9();
@@ -84839,17 +84876,19 @@ async function setAgentConfig(chatroomId, options, deps) {
   const machineId = await requireMachineId(d);
   const machineConfig = await d.machine.loadMachineConfig();
   const workingDir = options.workingDir ?? configuredWorkingDir(machineConfig) ?? process.cwd();
-  await d.backend.mutation(api.machines.saveTeamAgentConfig, {
+  await d.backend.mutation(api.machines.sendCommand, {
     sessionId,
-    chatroomId,
-    role: options.role,
-    type: "remote",
     machineId,
-    agentHarness: options.harness,
-    model: options.model,
-    workingDir
+    type: "start-agent",
+    payload: {
+      chatroomId,
+      role: options.role,
+      agentHarness: options.harness,
+      model: options.model,
+      workingDir
+    }
   });
-  console.log(`✅ Agent config saved for ${options.role}`);
+  console.log(`✅ Start command sent for ${options.role}`);
   console.log(`  Harness: ${options.harness}`);
   console.log(`  Model: ${options.model}`);
   console.log(`  Working directory: ${workingDir}`);
@@ -89739,6 +89778,7 @@ function toConvexLifecycleFact(fact) {
   return {
     ...normalized,
     chatroomId: normalized.chatroomId,
+    ...normalized.kind === "chatroom_shutdown_complete" ? { commandId: normalized.commandId } : {},
     ...(normalized.kind === "activity" || normalized.kind === "turn_failed") && normalized.taskId ? { taskId: normalized.taskId } : {}
   };
 }
@@ -89749,11 +89789,8 @@ function createAgentLifecycleSend(session2) {
       machineId: session2.machineId,
       fact: toConvexLifecycleFact(fact)
     };
-    const result = await session2.backend.mutation(api.machines.projectAgentLifecycleFact, args2);
-    return {
-      ...result,
-      ...result.skipped && result.rejectionReason ? { rejectionReason: result.rejectionReason } : {}
-    };
+    const result = await session2.backend.mutation(fact.kind === "activity" ? api.machines.recordAgentActivityHeartbeat : api.machines.projectAgentLifecycleFact, args2);
+    return result;
   };
 }
 var init_agent_lifecycle_send = __esm(() => {
@@ -89776,154 +89813,6 @@ var init_agent_lifecycle_outbox_runtime = __esm(() => {
   init_agent_lifecycle_send();
 });
 
-// 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/finalize-scoped-stop-execution.ts
-var exports_finalize_scoped_stop_execution = {};
-__export(exports_finalize_scoped_stop_execution, {
-  finalizeScopedStopExecution: () => finalizeScopedStopExecution
-});
-async function finalizeScopedStopExecution(args2) {
-  for (const { target, outcome, lifecycleWarning } of args2.result.targets) {
-    await args2.backend.mutation(api.agentStops.reportTargetOutcome, {
-      sessionId: args2.sessionId,
-      stopCommandId: args2.stopCommandId,
-      chatroomId: args2.chatroomId,
-      machineId: args2.machineId,
-      targetKey: target.targetKey,
-      role: target.role,
-      pid: target.pid,
-      status: "completed",
-      outcome: outcome.kind === "stopped" ? "stopped" : "already_stopped",
-      termination: outcome.termination,
-      lifecycleWarning
-    });
-  }
-  for (const failure of args2.result.failures) {
-    await args2.backend.mutation(api.agentStops.reportTargetOutcome, {
-      sessionId: args2.sessionId,
-      stopCommandId: args2.stopCommandId,
-      chatroomId: args2.chatroomId,
-      machineId: args2.machineId,
-      targetKey: failure.target.targetKey,
-      role: failure.target.role,
-      pid: failure.target.pid,
-      status: "failed",
-      outcome: "failed",
-      errorMessage: String(failure.error)
-    });
-  }
-  const failed = args2.result.failures.length > 0 || args2.executionError != null;
-  await args2.backend.mutation(api.agentStops.completeMachineExecution, {
-    sessionId: args2.sessionId,
-    stopCommandId: args2.stopCommandId,
-    machineId: args2.machineId,
-    status: failed ? "failed" : "completed",
-    errorMessage: failed ? args2.executionError ? String(args2.executionError) : `${args2.result.failures.length} target(s) failed` : undefined
-  });
-}
-var init_finalize_scoped_stop_execution = __esm(() => {
-  init_api3();
-});
-
-// src/daemon/entry/execute-scoped-stop-command.ts
-async function executeScopedStopForCommand(args2) {
-  args2.apm.markChatroomStopIntent(args2.chatroomId, args2.reason);
-  if (args2.scope.kind === "chatroom") {
-    await abortEnhancerSpawnsForChatroom(args2.chatroomId);
-  }
-  const { runExactTargetsStop: runExactTargetsStop2 } = await Promise.resolve().then(() => (init_service_interfaces(), exports_service_interfaces));
-  const finalize = await Promise.resolve().then(() => (init_finalize_scoped_stop_execution(), exports_finalize_scoped_stop_execution));
-  const begun = await args2.backend.mutation(api.agentStops.beginMachineExecution, {
-    sessionId: args2.sessionId,
-    stopCommandId: args2.stopCommandId,
-    machineId: args2.machineId,
-    inboxCommandId: args2.inboxCommandId
-  });
-  if (!begun.shouldExecute)
-    return { stoppedCount: 0, failedCount: 0 };
-  for (const target of begun.targets) {
-    args2.apm.markStopIntent(args2.chatroomId, target.role, args2.reason, target.pid);
-    args2.apm.bindStopTarget?.({
-      chatroomId: args2.chatroomId,
-      role: target.role,
-      pid: target.pid,
-      stopCommandId: args2.stopCommandId,
-      targetKey: target.targetKey
-    });
-  }
-  let result = { targets: [], failures: [] };
-  let executionError;
-  try {
-    const targetsByRole = new Map;
-    for (const target of begun.targets) {
-      const roleTargets = targetsByRole.get(target.role) ?? [];
-      roleTargets.push(target);
-      targetsByRole.set(target.role, roleTargets);
-    }
-    const roleResults = await Promise.all([...targetsByRole.entries()].map(([role, targets]) => args2.runSerializedForAgent({ chatroomId: args2.chatroomId, role }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (_ops, context5) => {
-      if (context5.signal.aborted)
-        throw context5.signal.reason;
-      return runExactTargetsStop2({
-        apm: args2.apm,
-        confirmedDeps: args2.apm.getConfirmedStopAdapterDeps(),
-        stopCommandId: args2.stopCommandId,
-        chatroomId: args2.chatroomId,
-        targets,
-        reason: args2.reason
-      });
-    })));
-    result = {
-      targets: roleResults.flatMap((roleResult) => roleResult.targets),
-      failures: roleResults.flatMap((roleResult) => roleResult.failures)
-    };
-  } catch (error) {
-    executionError = error;
-    console.warn("[daemon] scoped stop execution failed", error);
-  } finally {
-    await finalize.finalizeScopedStopExecution({ ...args2, result, executionError });
-    await args2.apm.syncSlotsAfterScopedStop(result);
-  }
-  return {
-    stoppedCount: result.targets.length,
-    failedCount: result.failures.length + (executionError != null ? 1 : 0),
-    executionError
-  };
-}
-var init_execute_scoped_stop_command = __esm(() => {
-  init_reliability();
-  init_api3();
-  init_enhancer_spawn_registry();
-});
-
 // src/daemon/entry/daemon-services.ts
 function DaemonMutableStateServiceLive(init2) {
   return exports_Layer.effect(DaemonMutableStateService, exports_Effect.gen(function* () {
@@ -89946,70 +89835,7 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, m
   loadEventCursor: (machineId) => exports_Effect.promise(() => ops.loadEventCursor(machineId))
 }), DaemonSpawningService, DaemonSpawningServiceLive = (ops) => exports_Layer.succeed(DaemonSpawningService, {
   shouldAllowSpawn: (chatroomId, reason) => ops.shouldAllowSpawn(chatroomId, reason)
-}), DaemonAgentProcessManagerService, DaemonAgentProcessManagerServiceLive = (mgr, processManagerService, sessionDeps) => exports_Layer.succeed(DaemonAgentProcessManagerService, {
-  executeScopedStopForCommand: (args2) => exports_Effect.promise(async () => {
-    if (!sessionDeps)
-      return { stoppedCount: 0, failedCount: 0 };
-    return executeScopedStopForCommand({
-      ...sessionDeps,
-      apm: mgr,
-      runSerializedForAgent: processManagerService.runSerializedForAgent,
-      ...args2
-    });
-  }),
-  runInboxRoleScopedStop: (event) => exports_Effect.promise(async () => {
-    const { runRoleScopedStop: runRoleScopedStop2 } = await Promise.resolve().then(() => (init_service_interfaces(), exports_service_interfaces));
-    const legacyReason = {
-      "team.switch": "platform.team_switch",
-      dedup: "platform.dedup",
-      "stale-config": "platform.dedup"
-    };
-    const reason = isAgentStopReason(event.reason) ? event.reason : legacyReason[event.reason] ?? "user.stop";
-    if (Date.now() > event.deadline)
-      return;
-    const execute = async (stopAgent, signal) => {
-      const result = await runRoleScopedStop2({
-        apm: mgr,
-        confirmedDeps: mgr.getConfirmedStopAdapterDeps(),
-        chatroomId: event.chatroomId,
-        role: event.role,
-        reason
-      });
-      if (result.targets.length === 0 && result.failures.length === 0 && event.pid) {
-        await stopAgent({
-          chatroomId: event.chatroomId,
-          role: event.role,
-          reason,
-          pid: event.pid
-        }, signal);
-      }
-      for (const failure of result.failures)
-        console.warn(`[daemon] scoped stop failed for ${failure.target.targetKey}`, failure.error);
-    };
-    await processManagerService.runSerializedForAgent({ chatroomId: event.chatroomId, role: event.role }, { timeoutMs: SCOPE_TARGET_STOP_TIMEOUT_MS }, async (ops, context5) => {
-      if (context5.signal.aborted)
-        throw context5.signal.reason;
-      await execute(ops.stopAgent, context5.signal);
-    });
-  }),
-  runInboxScopedStop: (event) => exports_Effect.promise(async () => {
-    if (!sessionDeps)
-      return;
-    const inboxCommandId = event.commandId ?? event._id;
-    const reason = isAgentStopReason(event.reason) ? event.reason : "user.stop";
-    await executeScopedStopForCommand({
-      sessionId: sessionDeps.sessionId,
-      machineId: sessionDeps.machineId,
-      backend: sessionDeps.backend,
-      apm: mgr,
-      stopCommandId: event.stopCommandId,
-      chatroomId: event.chatroomId,
-      scope: event.scope,
-      reason,
-      inboxCommandId,
-      runSerializedForAgent: processManagerService.runSerializedForAgent
-    });
-  }),
+}), DaemonAgentProcessManagerService, DaemonAgentProcessManagerServiceLive = (mgr, processManagerService) => exports_Layer.succeed(DaemonAgentProcessManagerService, {
   ensureRunning: (opts) => exports_Effect.promise(() => mgr.ensureRunning(opts)),
   stop: (opts) => exports_Effect.promise(() => mgr.stop(opts)),
   handleExit: (opts) => exports_Effect.promise(() => mgr.handleExit(opts)),
@@ -90024,10 +89850,7 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, m
 }), DaemonAgentProcessManagerCommandService, DaemonAgentProcessManagerCommandServiceLive = (service4) => exports_Layer.succeed(DaemonAgentProcessManagerCommandService, service4), DaemonSessionService, DaemonMutableStateService;
 var init_daemon_services = __esm(() => {
   init_esm();
-  init_reliability();
   init_agent_lifecycle_outbox_runtime();
-  init_execute_scoped_stop_command();
-  init_agent();
   init_service_interfaces();
   AgentLifecycleOutboxService = class AgentLifecycleOutboxService extends exports_Context.Tag("AgentLifecycleOutboxService")() {
   };
@@ -90055,11 +89878,7 @@ function daemonSessionToLayers(init2) {
   return exports_Layer.mergeAll(BackendServiceLive({
     mutation: (e, a) => init2.backend.mutation(e, a),
     query: (e, a) => init2.backend.query(e, a)
-  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), AgentLifecycleOutboxServiceLive(init2.agentLifecycleOutbox, init2.machineId), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager, init2.agentProcessManagerService, {
-    sessionId: init2.sessionId,
-    machineId: init2.machineId,
-    backend: init2.backend
-  }), DaemonAgentProcessManagerCommandServiceLive(init2.agentProcessManagerService), DaemonMutableStateServiceLive({
+  }), ProcessServiceLive, ClockServiceLive, FsServiceLive, DaemonMachineServiceLive(init2.machine), AgentLifecycleOutboxServiceLive(init2.agentLifecycleOutbox, init2.machineId), DaemonSpawningServiceLive(init2.spawning), DaemonAgentProcessManagerServiceLive(init2.agentProcessManager, init2.agentProcessManagerService), DaemonAgentProcessManagerCommandServiceLive(init2.agentProcessManagerService), DaemonMutableStateServiceLive({
     lastPushedGitState: init2.lastPushedGitState,
     lastPushedModels: init2.lastPushedModels,
     lastPushedHarnessFingerprint: init2.lastPushedHarnessFingerprint,
@@ -90080,12 +89899,16 @@ function daemonSessionToLayers(init2) {
     lastPushedModels: init2.lastPushedModels,
     lastPushedHarnessFingerprint: init2.lastPushedHarnessFingerprint,
     logEvent: init2.logEvent,
-    taskService: init2.taskService
+    taskService: init2.taskService,
+    lifecycleOutbox: {
+      enqueue: (fact) => enqueueAgentLifecycleFact(init2.agentLifecycleOutbox, init2.machineId, fact)
+    }
   }));
 }
 var init_daemon_layers = __esm(() => {
   init_esm();
   init_daemon_services();
+  init_agent_lifecycle_outbox_runtime();
   init_backend();
   init_clock2();
   init_fs();
@@ -90978,10 +90801,9 @@ Run: ${formatAuthLoginCommand(convexUrl)}`);
   yield* connectDaemonEffect(client4, typedSessionId, machineId);
   return { typedSessionId, config: config3, machineId, agentServices, cachedModels };
 }), activeLogSink, activeLogEvent, connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
-  try: () => client4.mutation(api.machines.updateDaemonStatus, {
+  try: () => client4.mutation(api.machines.markDaemonOnline, {
     sessionId: asConvexSessionId(sessionId),
-    machineId,
-    connected: true
+    machineId
   }),
   catch: (e) => e
 }).pipe(exports_Effect.catchAll((error) => {
@@ -94519,8 +94341,6 @@ var init_command_event_types = __esm(() => {
   DAEMON_COMMAND_EVENT_TYPES = [
     "agent.requestStart",
     "agent.restart",
-    "agent.requestStop",
-    "agent.stopScope",
     "daemon.ping",
     "daemon.gitRefresh",
     "daemon.workspaceListChanged",
@@ -96193,8 +96013,7 @@ async function restartAgent(deps, input) {
       model: input.model,
       workingDir: input.workingDir,
       correlationId: input.correlationId,
-      wantResume: input.wantResume,
-      ...input.lifecycleRevision !== undefined ? { lifecycleRevision: input.lifecycleRevision } : {}
+      wantResume: input.wantResume
     });
   } catch (error) {
     log4(`[daemon] agent.restart failed (correlationId=${input.correlationId}) for role=${input.role}: ${error instanceof Error ? error.message : String(error)}`);
@@ -96360,13 +96179,16 @@ function createStartAgentDeps(session2, processManagerService) {
             machineId: session2.machineId,
             error: args2.error
           });
-          await session2.backend.mutation(api.daemon.agentEvents.agentStartFailed, {
-            sessionId: session2.sessionId,
-            machineId: session2.machineId,
-            chatroomId: args2.chatroomId,
-            role: args2.role,
-            error: args2.error
-          });
+          if (session2.lifecycleOutbox) {
+            await session2.lifecycleOutbox.enqueue(buildAgentStatusFact({
+              chatroomId: args2.chatroomId,
+              role: args2.role,
+              status: "error",
+              errorSource: "configuration",
+              errorCode: "agent.startFailed",
+              errorMessage: args2.error
+            }));
+          }
         } catch (err) {
           console.log(`   ⚠️  Failed to emit startFailed event: ${err.message}`);
         }
@@ -96434,8 +96256,7 @@ var onRequestRestartAgentEffect = (event, nativeDelivery) => exports_Effect.gen(
     workingDir: event.workingDir,
     correlationId: event.correlationId,
     deadline: event.deadline,
-    wantResume: event.wantResume,
-    lifecycleRevision: event.lifecycleRevision
+    wantResume: event.wantResume
   }));
 });
 var init_on_request_restart_agent = __esm(() => {
@@ -96461,8 +96282,7 @@ async function startAgent2(deps, input) {
       model: input.model,
       workingDir: input.workingDir,
       reason: input.reason,
-      wantResume: input.wantResume,
-      ...input.lifecycleRevision !== undefined ? { lifecycleRevision: input.lifecycleRevision } : {}
+      wantResume: input.wantResume
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : typeof error === "object" && error !== null && ("error" in error) ? String(error.error) : "unknown";
@@ -96508,8 +96328,7 @@ var onRequestStartAgentEffect = (event) => exports_Effect.gen(function* () {
       workingDir: event.workingDir,
       reason: event.reason,
       deadline: event.deadline,
-      wantResume: event.wantResume,
-      lifecycleRevision: event.lifecycleRevision
+      wantResume: event.wantResume
     });
     await drainPendingEnhancerJobsIfRegistered();
   });
@@ -96520,31 +96339,6 @@ var init_on_request_start_agent = __esm(() => {
   init_daemon_services();
 });
 
-// src/daemon/entry/events/agent/on-request-stop-agent.ts
-var onRequestStopAgentEffect = (event) => exports_Effect.gen(function* () {
-  const agentMgr = yield* DaemonAgentProcessManagerService;
-  if (Date.now() > event.deadline)
-    return;
-  if (agentMgr.runInboxRoleScopedStop)
-    yield* agentMgr.runInboxRoleScopedStop(event);
-});
-var init_on_request_stop_agent = __esm(() => {
-  init_esm();
-  init_daemon_services();
-});
-
-// src/daemon/entry/events/agent/on-stop-scope-agent.ts
-var onStopScopeAgentEffect = (event) => exports_Effect.gen(function* () {
-  const agentMgr = yield* DaemonAgentProcessManagerService;
-  const stop4 = agentMgr.runInboxScopedStop;
-  if (stop4)
-    yield* stop4(event);
-});
-var init_on_stop_scope_agent = __esm(() => {
-  init_esm();
-  init_daemon_services();
-});
-
 // src/daemon/entry/handlers/ping.ts
 function handlePing() {
   console.log(`   ↪ Responding: pong`);
@@ -96722,15 +96516,6 @@ function handleRequestRestartEffect(event, tracker, nativeDelivery) {
     tracker.commandIds.set(eventId, Date.now());
   });
 }
-function handleRequestStopEffect(event, tracker) {
-  return exports_Effect.gen(function* () {
-    const eventId = event._id.toString();
-    if (tracker.commandIds.has(eventId))
-      return;
-    yield* onRequestStopAgentEffect(event);
-    tracker.commandIds.set(eventId, Date.now());
-  });
-}
 function handlePingCommandEffect(event, tracker) {
   return exports_Effect.gen(function* () {
     const eventId = event._id.toString();
@@ -96884,8 +96669,6 @@ var init_command_dispatch = __esm(() => {
   init_pick_folder();
   init_on_request_restart_agent();
   init_on_request_start_agent();
-  init_on_request_stop_agent();
-  init_on_stop_scope_agent();
   init_ping();
   init_manager();
   init_convex_error();
@@ -96893,14 +96676,6 @@ var init_command_dispatch = __esm(() => {
   commandEventHandlers = {
     "agent.requestStart": handleRequestStartEffect,
     "agent.restart": handleRequestRestartEffect,
-    "agent.requestStop": handleRequestStopEffect,
-    "agent.stopScope": (event, tracker) => exports_Effect.gen(function* () {
-      const eventId = String(event.commandId ?? event._id);
-      if (tracker.commandIds.has(eventId))
-        return;
-      yield* onStopScopeAgentEffect(event);
-      tracker.commandIds.set(eventId, Date.now());
-    }),
     "daemon.ping": handlePingCommandEffect,
     "daemon.gitRefresh": handleGitRefreshCommandEffect,
     "daemon.workspaceListChanged": handleWorkspaceListChangedCommandEffect,
@@ -96956,6 +96731,36 @@ function createEnhancerLogWriter(logSink, context5, clock4 = () => Date.now()) {
 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;
@@ -103126,7 +102931,7 @@ var init_command_run_subscription = __esm(() => {
 });
 
 // src/daemon/entry/task-inbox-runtime.ts
-var startTaskInboxEffect = () => exports_Effect.gen(function* () {
+var startTaskInboxEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const agentMgr = yield* DaemonAgentProcessManagerService;
   const commandService = yield* DaemonAgentProcessManagerCommandService;
@@ -103154,12 +102959,12 @@ var startTaskInboxEffect = () => exports_Effect.gen(function* () {
     runSerializedForAgent: commandService.runSerializedForAgent,
     sessionDeps,
     machineId: session2.machineId,
-    taskSnapshotState: session2.taskService.taskSnapshotState,
+    taskInboxState: session2.taskService.taskInboxState,
     agentTaskState,
     lifecycleOutbox,
     taskService: session2.taskService
   });
-  yield* exports_Effect.tryPromise(() => session2.taskService.startTaskInbox()).pipe(exports_Effect.catchAll((error) => {
+  yield* exports_Effect.tryPromise(() => session2.taskService.startTaskInbox(wsClient2)).pipe(exports_Effect.catchAll((error) => {
     console.warn("[TaskService] task inbox bootstrap failed:", error);
     return exports_Effect.void;
   }));
@@ -103532,10 +103337,9 @@ var init_on_daemon_shutdown = __esm(() => {
         console.log(`[${formatTimestamp()}] Shutdown stops: ${totalStopped} stopped`);
       }
     }
-    yield* exports_Effect.promise(() => session2.backend.mutation(api.machines.updateDaemonStatus, {
+    yield* exports_Effect.promise(() => session2.backend.mutation(api.machines.markDaemonOffline, {
       sessionId: session2.sessionId,
-      machineId: session2.machineId,
-      connected: false
+      machineId: session2.machineId
     }).catch(() => {}));
   });
 });
@@ -103688,7 +103492,7 @@ function createDaemonRuntime(deps) {
           break;
       }
     });
-    taskInboxHandle = yield* startTaskInboxEffect();
+    taskInboxHandle = yield* startTaskInboxEffect(deps.wsClient);
     logObserverSubscriptionHandle = startLogObserverSubscription({ sessionId: session2.sessionId, machineId: session2.machineId }, deps.wsClient);
     const commandRunRuntime = yield* exports_Effect.runtime();
     agenticQueryWorkerHandle = startAgenticQuerySubscriptions({
@@ -104151,6 +103955,48 @@ var init_deps = __esm(() => {
   init_publisher_registry();
 });
 
+// src/daemon/entry/execute-chatroom-stop-command.ts
+async function executeChatroomStopCommand(args2) {
+  if (args2.role)
+    args2.apm.markStopIntent(args2.chatroomId, args2.role, "user.stop");
+  else {
+    args2.apm.markChatroomStopIntent(args2.chatroomId, "user.stop");
+    await abortEnhancerSpawnsForChatroom(args2.chatroomId);
+  }
+  const confirmedDeps = args2.apm.getConfirmedStopAdapterDeps();
+  const targets = await args2.apm.discoverStopTargets(args2.chatroomId);
+  const roles = [
+    ...new Set(targets.filter((target) => !args2.role || target.role.toLowerCase() === args2.role.toLowerCase()).map((target) => target.role.toLowerCase()))
+  ];
+  const results = await Promise.allSettled(roles.map((role) => args2.runSerializedForAgent({ chatroomId: args2.chatroomId, role }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (_ops, context5) => {
+    if (context5.signal.aborted)
+      throw context5.signal.reason;
+    await runRoleScopedStop({
+      apm: args2.apm,
+      confirmedDeps,
+      chatroomId: args2.chatroomId,
+      role,
+      reason: "user.stop"
+    });
+  })));
+  for (const result of results)
+    if (result.status === "rejected")
+      console.warn("[daemon] chatroom stop attempt failed", result.reason);
+  await confirmedDeps.lifecycleOutbox.enqueue({
+    kind: "chatroom_shutdown_complete",
+    chatroomId: args2.chatroomId,
+    commandId: args2.commandId,
+    ...args2.finalizeChatroom === undefined ? {} : { finalizeChatroom: args2.finalizeChatroom },
+    revisionKey: `shutdown:${args2.commandId}`,
+    emittedAt: Date.now()
+  });
+}
+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 homedir10 } from "node:os";
 import { join as join26 } from "node:path";
@@ -104677,6 +104523,10 @@ function startAllSubscribers(deps) {
   const enhancerJob = startEnhancerJobSubscriber2(deps, onEvent);
   const gitRequest = startGitRequestSubscriber(deps, onEvent);
   const machineCommands = startMachineCommandInboxSubscriber(deps, async (claimed) => {
+    if (claimed.type === "agent.stop") {
+      await deps.onAgentStopCommand?.(claimed);
+      return;
+    }
     if (claimed.type === "daemon.workspaceListChanged") {
       enhancerJob.refreshChatrooms();
       gitRequest.refreshWorkspaces();
@@ -133877,7 +133727,18 @@ async function startDaemon() {
     wsClient: wsClient2,
     sessionId: asConvexSessionId(init2.sessionId),
     machineId: init2.machineId,
-    router: createDefaultEventRouterDeps()
+    router: createDefaultEventRouterDeps(),
+    onAgentStopCommand: (command) => {
+      const stopCommand = command;
+      return executeChatroomStopCommand({
+        apm: init2.agentProcessManager,
+        chatroomId: stopCommand.chatroomId,
+        commandId: stopCommand.commandId,
+        role: stopCommand.role,
+        finalizeChatroom: stopCommand.finalizeChatroom,
+        runSerializedForAgent: init2.agentProcessManagerService.runSerializedForAgent
+      });
+    }
   });
   console.log(`[daemon] Local web UI: http://127.0.0.1:${localWeb.port}/`);
   const layers = daemonSessionToLayers(init2);
@@ -133906,6 +133767,7 @@ var init_start_daemon = __esm(() => {
   init_daemon_runtime();
   init_default_router_deps();
   init_deps();
+  init_execute_chatroom_stop_command();
   init_init_daemon();
   init_persistence_path();
   init_resolve_local_web_port();
@@ -134679,7 +134541,7 @@ agentConfigCommand.command("get").description("Show agent configuration for a ro
   const { getAgentConfig: getAgentConfig2 } = await Promise.resolve().then(() => (init_agent2(), exports_agent));
   await getAgentConfig2(options.chatroomId, options.role);
 });
-agentConfigCommand.command("set").description("Save agent harness and model configuration").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Agent role").requiredOption("--harness <harness>", "Agent harness").requiredOption("--model <model>", "Model identifier").option("--working-dir <dir>", "Agent working directory").action(async (options) => {
+agentConfigCommand.command("set").description("Send a one-time agent start request with the harness and model").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Agent role").requiredOption("--harness <harness>", "Agent harness").requiredOption("--model <model>", "Model identifier").option("--working-dir <dir>", "Agent working directory").action(async (options) => {
   await maybeRequireAuth();
   const { setAgentConfig: setAgentConfig2 } = await Promise.resolve().then(() => (init_agent2(), exports_agent));
   await setAgentConfig2(options.chatroomId, options);
@@ -135146,4 +135008,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=7D04CA8EEEBFA97564756E2164756E21
+//# debugId=D0F3FF58E9CFA79B64756E2164756E21