chatroom-cli 1.115.4 → 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, 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" || kind === "chatroom_shutdown_complete") {
+  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,6 +28143,26 @@ 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__`;
@@ -28155,23 +28174,55 @@ 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 taskRequestsNativeColdSession(task) {
@@ -28574,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, {
@@ -28631,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();
 });
@@ -29693,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
@@ -29741,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" };
   }
@@ -29782,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({
@@ -29871,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();
@@ -30281,6 +30346,9 @@ function defaultNativeTurnPhase() {
 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";
@@ -30766,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 {
@@ -30787,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);
@@ -30799,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" } };
@@ -30832,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);
@@ -30911,15 +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 (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);
@@ -30992,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 });
         }
@@ -31421,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;
@@ -31480,19 +31556,27 @@ class AgentProcessManager {
     } else if (slot.stopRequested) {
       return { success: false, error: "stop_requested" };
     }
-    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;
@@ -31577,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;
@@ -31585,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();
@@ -31598,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);
@@ -31646,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,
@@ -31717,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) {
@@ -31762,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;
@@ -31807,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);
@@ -31823,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 });
       }
@@ -31841,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;
@@ -31917,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;
@@ -31946,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);
@@ -31972,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);
@@ -32071,7 +32155,7 @@ class AgentProcessManager {
     }
   }
   resetSlotIdle(slot) {
-    slot.state = "idle";
+    slot.state = AGENT_SLOT_STATE.IDLE;
     slot.pendingOperation = undefined;
   }
   checkRateLimitGate(opts, slot) {
@@ -32164,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;
@@ -32336,7 +32420,7 @@ 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,
@@ -32364,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}` };
@@ -32398,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;
@@ -32499,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
@@ -32535,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();
@@ -32610,8 +32701,14 @@ function createTaskService(deps) {
   const gateway = createConvexNativeTaskDeliveryGateway(deps.backend);
   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))));
   };
@@ -32638,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;
+    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;
-    inboxPollInFlight = true;
+    }
+    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,
@@ -32712,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();
 });
 
@@ -83736,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,
@@ -83768,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}"`);
     });
@@ -84442,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,
@@ -84531,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"],
@@ -84622,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(", ")}`);
@@ -84672,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
   });
@@ -84688,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();
@@ -84696,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}`);
@@ -89607,7 +89789,7 @@ function createAgentLifecycleSend(session2) {
       machineId: session2.machineId,
       fact: toConvexLifecycleFact(fact)
     };
-    const result = await session2.backend.mutation(api.machines.projectAgentLifecycleFact, args2);
+    const result = await session2.backend.mutation(fact.kind === "activity" ? api.machines.recordAgentActivityHeartbeat : api.machines.projectAgentLifecycleFact, args2);
     return result;
   };
 }
@@ -89717,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();
@@ -90615,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) => {
@@ -95994,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}`);
         }
@@ -102743,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;
@@ -102776,7 +102964,7 @@ var startTaskInboxEffect = () => exports_Effect.gen(function* () {
     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;
   }));
@@ -103149,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(() => {}));
   });
 });
@@ -103305,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({
@@ -103955,45 +104142,6 @@ var init_agentic_query_session = __esm(() => {
   init_api3();
 });
 
-// src/daemon/infrastructure/convex/subscribers/chatroom-workspace-agent-commands.ts
-function startChatroomWorkspaceAgentCommandsSubscriber(deps, onClaimed) {
-  let draining = false;
-  let queued = false;
-  let stopped = false;
-  const args2 = { sessionId: deps.sessionId, machineId: deps.machineId };
-  const drain = async () => {
-    if (stopped || draining) {
-      queued = true;
-      return;
-    }
-    draining = true;
-    try {
-      do {
-        queued = false;
-        let claimed;
-        while (claimed = await deps.wsClient.mutation(api.chatroomWorkspaceAgentCommandsInbox.claimNext, args2))
-          await onClaimed(claimed);
-      } while (queued && !stopped);
-    } finally {
-      draining = false;
-    }
-  };
-  const unsub = deps.wsClient.onUpdate(api.chatroomWorkspaceAgentCommandsInbox.watchNext, args2, (commandId) => {
-    if (commandId)
-      drain();
-  }, (err) => console.warn(`[daemon] workspace-agent-command watch error: ${String(err)}`));
-  drain();
-  return {
-    async stop() {
-      stopped = true;
-      unsub();
-    }
-  };
-}
-var init_chatroom_workspace_agent_commands = __esm(() => {
-  init_api3();
-});
-
 // src/daemon/infrastructure/convex/subscribers/command-run.ts
 function runId(run3) {
   return typeof run3._id === "string" ? run3._id : run3._id.toString();
@@ -104375,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();
@@ -104386,7 +104538,6 @@ function startAllSubscribers(deps) {
       claimedCommand: claimed
     });
   });
-  const workspaceAgentCommands = deps.onWorkspaceAgentCommand ? startChatroomWorkspaceAgentCommandsSubscriber(deps, deps.onWorkspaceAgentCommand) : undefined;
   const commandRun = startCommandRunSubscriber(deps, onEvent);
   const fileTree = startFileTreeRequestSubscriber(deps, onEvent);
   const fileTreeRelease = startFileTreeReleaseRequestSubscriber(deps, onEvent);
@@ -104398,7 +104549,6 @@ function startAllSubscribers(deps) {
     async stopAll() {
       await Promise.all([
         machineCommands.stop(),
-        workspaceAgentCommands?.stop(),
         commandRun.stop(),
         gitRequest.stop(),
         fileTree.stop(),
@@ -104416,7 +104566,6 @@ var init_subscriber_registry = __esm(() => {
   init_event_router();
   init_agentic_query_prompt();
   init_agentic_query_session();
-  init_chatroom_workspace_agent_commands();
   init_command_run();
   init_enhancer_job();
   init_file_content_request();
@@ -133579,14 +133728,17 @@ async function startDaemon() {
     sessionId: asConvexSessionId(init2.sessionId),
     machineId: init2.machineId,
     router: createDefaultEventRouterDeps(),
-    onWorkspaceAgentCommand: (command) => executeChatroomStopCommand({
-      apm: init2.agentProcessManager,
-      chatroomId: command.chatroomId,
-      commandId: command._id,
-      role: command.command.type === "stop_agent" ? command.command.role : undefined,
-      finalizeChatroom: command.command.type === "stop_all_agents" ? command.command.finalizeChatroom : undefined,
-      runSerializedForAgent: init2.agentProcessManagerService.runSerializedForAgent
-    })
+    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);
@@ -134389,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);
@@ -134856,4 +135008,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=1E9B97C58361134164756E2164756E21
+//# debugId=D0F3FF58E9CFA79B64756E2164756E21