chatroom-cli 1.57.0 → 1.57.1

package/dist/index.js

@@ -29173,7 +29173,7 @@ function writeSpawnError(logPrefix, err, emitLogLine) {
   emitLogLine?.(line);
   console.error(`[${new Date().toISOString()}] ${logPrefix} spawn-error]`, err);
 }
-var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache, _sdkLoadError, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 1e4, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion, CursorSdkAgentService;
+var NO_SUBAGENT_DIRECTIVE2 = "NEVER spawn subagents. Follow the chatroom instructions strictly.", _sdkCache, _sdkLoadError, CURSOR_SDK_COMMAND = "cursor-sdk", DEFAULT_MODEL = "composer-2.5", AGENT_CREATE_TIMEOUT_MS = 60000, SEND_TIMEOUT_MS = 60000, RUN_WAIT_TIMEOUT_MS = 3600000, MODELS_LIST_TIMEOUT_MS = 60000, RUN_CANCEL_TIMEOUT_MS = 5000, cachedSdkPackageVersion, CursorSdkAgentService;
 var init_cursor_sdk_agent_service = __esm(() => {
   init_esm();
   init_base_cli_agent_service();
@@ -80624,19 +80624,51 @@ function isDaemonRunning() {
   removePid();
   return { running: false, pid: null };
 }
-function acquireLock() {
-  const { running: running3, pid } = isDaemonRunning();
+function tryAcquireLock() {
+  const { running: running3 } = isDaemonRunning();
   if (running3) {
-    console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
     return false;
   }
   writePid();
   return true;
 }
+function logWaitingForShutdown(pid) {
+  console.error(`⏳ Waiting for previous daemon to shut down for ${getConvexUrl()} (PID: ${pid})...`);
+}
+function logDaemonAlreadyRunning(pid) {
+  console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
+}
+async function waitForLockOrTimeout(deadline, intervalMs, sleep5) {
+  let loggedWait = false;
+  while (Date.now() < deadline) {
+    if (tryAcquireLock()) {
+      return true;
+    }
+    const { pid } = isDaemonRunning();
+    if (pid !== null && !loggedWait) {
+      logWaitingForShutdown(pid);
+      loggedWait = true;
+    }
+    await sleep5(intervalMs);
+  }
+  return false;
+}
+async function acquireLockWithRetry(options) {
+  const intervalMs = options?.intervalMs ?? LOCK_RETRY_INTERVAL_MS;
+  const maxWaitMs = options?.maxWaitMs ?? LOCK_RETRY_MAX_WAIT_MS;
+  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
+  const deadline = Date.now() + maxWaitMs;
+  if (await waitForLockOrTimeout(deadline, intervalMs, sleep5)) {
+    return true;
+  }
+  const { pid } = isDaemonRunning();
+  logDaemonAlreadyRunning(pid);
+  return false;
+}
 function releaseLock() {
   removePid();
 }
-var CHATROOM_DIR4;
+var CHATROOM_DIR4, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000;
 var init_pid = __esm(() => {
   init_client2();
   CHATROOM_DIR4 = join16(homedir6(), ".chatroom");
@@ -84918,6 +84950,315 @@ class TurnEndQueue {
   }
 }
 
+// src/commands/machine/daemon-start/native-delivery-ledger.ts
+class NativeDeliveryLedger {
+  delivered = new Set;
+  inFlight = new Set;
+  deliveryKey(taskId, harnessSessionId) {
+    return `${taskId}\x00${harnessSessionId}`;
+  }
+  isDelivered(taskId, harnessSessionId) {
+    return this.delivered.has(this.deliveryKey(taskId, harnessSessionId));
+  }
+  tryAcquire(taskId, harnessSessionId) {
+    const key = this.deliveryKey(taskId, harnessSessionId);
+    if (this.delivered.has(key) || this.inFlight.has(key)) {
+      return false;
+    }
+    this.inFlight.add(key);
+    return true;
+  }
+  markDelivered(taskId, harnessSessionId) {
+    const key = this.deliveryKey(taskId, harnessSessionId);
+    this.inFlight.delete(key);
+    this.delivered.add(key);
+  }
+  clearDelivery(taskId, harnessSessionId) {
+    const key = this.deliveryKey(taskId, harnessSessionId);
+    this.inFlight.delete(key);
+    this.delivered.delete(key);
+  }
+  clearSession(harnessSessionId) {
+    const suffix = `\x00${harnessSessionId}`;
+    for (const key of [...this.delivered, ...this.inFlight]) {
+      if (key.endsWith(suffix)) {
+        this.delivered.delete(key);
+        this.inFlight.delete(key);
+      }
+    }
+  }
+}
+
+// src/domain/native-integration/predicates.ts
+function isNativeInjectableAliveRunning(task) {
+  const { agentConfig, status: status3 } = task;
+  if (!isNativeHarness(agentConfig.agentHarness))
+    return false;
+  if (agentConfig.spawnedAgentPid == null || agentConfig.desiredState !== "running") {
+    return false;
+  }
+  if (status3 === "pending")
+    return true;
+  if (status3 === "acknowledged") {
+    const assignedTo = task.assignedTo?.toLowerCase();
+    return assignedTo === agentConfig.role.toLowerCase();
+  }
+  return false;
+}
+function isInjectableNativeAction(action) {
+  if (action == null)
+    return true;
+  return action === NATIVE_WAITING_ACTION;
+}
+function isNativeIdleAfterTaskComplete(participant) {
+  return participant.lastSeenAction === NATIVE_TASK_INJECTED_ACTION && participant.lastStatus === "task.completed";
+}
+function isNativeAcknowledgedInjectionRetry(task) {
+  if (task.status !== "acknowledged")
+    return false;
+  const assignedTo = task.assignedTo?.toLowerCase();
+  if (assignedTo !== task.agentConfig.role.toLowerCase())
+    return false;
+  return task.participant?.lastSeenAction === NATIVE_TASK_INJECTED_ACTION;
+}
+function isStaleCliGetNextTaskWaiting(task) {
+  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
+  return task.participant?.lastSeenAction === "get-next-task:started" && task.createdAt > lastSeenAt;
+}
+function isCliIdleNotListening(task, now, thresholdMs) {
+  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
+  if (lastSeenAt === 0)
+    return now - task.createdAt > thresholdMs;
+  return now - lastSeenAt > thresholdMs;
+}
+var init_predicates = __esm(() => {
+  init_types();
+  init_participant();
+});
+
+// src/infrastructure/services/remote-agents/spawn-prompt.ts
+function createSpawnPrompt(raw, opts) {
+  if (opts?.nativeBootstrap) {
+    return NATIVE_BOOTSTRAP_PROMPT;
+  }
+  const trimmed = raw?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_TRIGGER_PROMPT;
+}
+var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.", NATIVE_BOOTSTRAP_PROMPT = "Focus on your role responsibilities. Complete each task via handoff.";
+
+// src/domain/native-integration/spawn-policy.ts
+function shouldDeferInitialTurn(harness) {
+  return isNativeHarness(harness);
+}
+function resolveNativeSpawnPolicy(harness, initMessage) {
+  const deferInitialTurn = shouldDeferInitialTurn(harness);
+  return {
+    deferInitialTurn,
+    prompt: createSpawnPrompt(initMessage, { nativeBootstrap: deferInitialTurn })
+  };
+}
+var init_spawn_policy = __esm(() => {
+  init_types();
+});
+
+// src/domain/native-integration/index.ts
+var init_native_integration = __esm(() => {
+  init_types();
+  init_predicates();
+  init_spawn_policy();
+});
+
+// src/commands/machine/daemon-start/native-task-injector-logic.ts
+function shouldDeliverNativeTask(task, opts) {
+  if (!isNativeInjectableAliveRunning(task))
+    return false;
+  if (!opts.harnessSessionId)
+    return false;
+  if (opts.ledger.isDelivered(task.taskId, opts.harnessSessionId))
+    return false;
+  return isInjectableNativeAction(task.participant?.lastSeenAction) || isNativeIdleAfterTaskComplete(task.participant ?? {}) || isNativeAcknowledgedInjectionRetry(task);
+}
+function buildNativeInjectionPrompt(params) {
+  const { taskDeliveryOutput, compressMode } = params;
+  if (compressMode === "new_session") {
+    return [
+      "⚠️ Context was compacted. Run `chatroom get-system-prompt` only if role instructions are missing.",
+      "",
+      taskDeliveryOutput
+    ].join(`
+`);
+  }
+  return taskDeliveryOutput;
+}
+var init_native_task_injector_logic = __esm(() => {
+  init_predicates();
+  init_native_integration();
+});
+
+// ../../services/backend/src/domain/handoff/parse-compress-context.ts
+function findSectionIndex(content, headings) {
+  const indices = headings.map((heading) => content.indexOf(heading)).filter((idx) => idx !== -1);
+  return indices.length === 0 ? -1 : Math.min(...indices);
+}
+function normalizeMode(raw) {
+  const value = raw.toLowerCase();
+  if (value === "reset")
+    return "new_session";
+  if (value === "none")
+    return value;
+  return DEFAULT_MODE;
+}
+function extractSectionBody(content, sectionIdx) {
+  const matchedHeading = SECTION_HEADINGS.find((h) => content.indexOf(h, sectionIdx) === sectionIdx) ?? SECTION_HEADINGS[0];
+  const afterSection = content.slice(sectionIdx);
+  const nextHeading = afterSection.slice(matchedHeading.length).search(/\n## /);
+  return nextHeading === -1 ? afterSection : afterSection.slice(0, matchedHeading.length + nextHeading);
+}
+function parseCompressContext(handoffContent) {
+  const sectionIdx = findSectionIndex(handoffContent, SECTION_HEADINGS);
+  if (sectionIdx === -1)
+    return DEFAULT_MODE;
+  const match17 = extractSectionBody(handoffContent, sectionIdx).match(DATA_TAG);
+  if (!match17)
+    return DEFAULT_MODE;
+  return normalizeMode(match17[1]);
+}
+function compressContextToWantResume(mode) {
+  return mode === "none";
+}
+var SECTION_HEADINGS, DATA_TAG, DEFAULT_MODE = "new_session";
+var init_parse_compress_context = __esm(() => {
+  SECTION_HEADINGS = ["## Session Management", "## Restart new context"];
+  DATA_TAG = /\/\/\s*data:agent\.compress_context=(new_session|reset|none)\b/i;
+});
+
+// src/commands/machine/daemon-start/native-task-injector.ts
+function runNativeInjectionEffect(task, harnessSessionId, deps, ledger) {
+  return exports_Effect.gen(function* () {
+    if (!shouldDeliverNativeTask(task, { ledger, harnessSessionId })) {
+      return;
+    }
+    const { chatroomId, taskId, taskContent, agentConfig, status: status3 } = task;
+    const { role } = agentConfig;
+    if (!ledger.tryAcquire(taskId, harnessSessionId)) {
+      return;
+    }
+    if (status3 === "pending") {
+      const claimResult = yield* exports_Effect.tryPromise({
+        try: () => deps.backend.mutation(api.tasks.claimTask, {
+          sessionId: deps.sessionId,
+          chatroomId,
+          role,
+          taskId
+        }),
+        catch: (err) => err
+      }).pipe(exports_Effect.either);
+      if (claimResult._tag === "Left") {
+        ledger.clearDelivery(taskId, harnessSessionId);
+        return yield* exports_Effect.fail(claimResult.left);
+      }
+    }
+    const deliveryResult = yield* exports_Effect.tryPromise({
+      try: () => deps.backend.query(api.messages.getTaskDeliveryPrompt, {
+        sessionId: deps.sessionId,
+        chatroomId,
+        role,
+        taskId,
+        convexUrl: deps.convexUrl
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (deliveryResult._tag === "Left") {
+      ledger.clearDelivery(taskId, harnessSessionId);
+      return yield* exports_Effect.fail(deliveryResult.left);
+    }
+    const delivery = deliveryResult.right;
+    const prompt = buildNativeInjectionPrompt({
+      taskDeliveryOutput: delivery.fullCliOutput,
+      compressMode: parseCompressContext(taskContent)
+    });
+    yield* exports_Effect.tryPromise({
+      try: () => deps.backend.mutation(api.participants.join, {
+        sessionId: deps.sessionId,
+        chatroomId,
+        role,
+        action: NATIVE_TASK_INJECTED_ACTION,
+        taskId
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.tapError(() => exports_Effect.sync(() => ledger.clearDelivery(taskId, harnessSessionId))));
+    const resumeResult = yield* exports_Effect.tryPromise({
+      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (resumeResult._tag === "Left") {
+      ledger.clearDelivery(taskId, harnessSessionId);
+      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${getErrorMessage(resumeResult.left)}`);
+      return;
+    }
+    ledger.markDelivered(taskId, harnessSessionId);
+  });
+}
+var init_native_task_injector = __esm(() => {
+  init_participant();
+  init_parse_compress_context();
+  init_esm();
+  init_native_task_injector_logic();
+  init_api3();
+  init_convex_error();
+});
+
+// src/commands/machine/daemon-start/native-task-delivery-coordinator.ts
+class NativeTaskDeliveryCoordinator {
+  ledger;
+  constructor(ledger = new NativeDeliveryLedger) {
+    this.ledger = ledger;
+  }
+  onSessionLost(params) {
+    if (params.harnessSessionId) {
+      this.ledger.clearSession(params.harnessSessionId);
+    }
+  }
+  reconcileAssignedTasks(params) {
+    const { tasks, runtime: runtime4, effectContext: effectContext2, agentMgr, sessionDeps } = params;
+    for (const task of tasks) {
+      const slot = agentMgr.getSlot(task.chatroomId, task.agentConfig.role);
+      const harnessSessionId = slot?.harnessSessionId;
+      if (!shouldDeliverNativeTask(task, {
+        ledger: this.ledger,
+        harnessSessionId
+      })) {
+        continue;
+      }
+      if (!harnessSessionId) {
+        continue;
+      }
+      exports_Runtime.runFork(runtime4)(runNativeInjectionEffect(task, harnessSessionId, {
+        sessionId: sessionDeps.sessionId,
+        backend: sessionDeps.backend,
+        agentMgr: {
+          resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
+        },
+        convexUrl: sessionDeps.convexUrl
+      }, this.ledger).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${task.agentConfig.role}@${task.chatroomId}: ${getErrorMessage(err)}`)))));
+    }
+  }
+}
+function getNativeTaskDeliveryCoordinator() {
+  coordinator ??= new NativeTaskDeliveryCoordinator;
+  return coordinator;
+}
+function notifyNativeSessionLost(params) {
+  getNativeTaskDeliveryCoordinator().onSessionLost(params);
+}
+var coordinator;
+var init_native_task_delivery_coordinator = __esm(() => {
+  init_esm();
+  init_native_task_injector_logic();
+  init_native_task_injector();
+  init_convex_error();
+});
+
 // src/domain/agent-lifecycle/entities/stop-reason.ts
 function resolveStopReason(code2, signal) {
   if (signal !== null)
@@ -85089,6 +85430,45 @@ var init_agent_lifecycle = __esm(() => {
   init_restart_decision();
 });
 
+// src/domain/agent-lifecycle/policies/cursor-sdk-run-error.ts
+function isCursorSdkRunErrorInLogs(logLines) {
+  return logLines.some((line) => line.includes(" run-error]"));
+}
+function formatCursorSdkRunErrorMessage(logLines) {
+  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
+  return line?.trim() ?? "Cursor SDK run failed";
+}
+
+// src/commands/machine/daemon-start/native-harness-session-exit.ts
+function isNativeHarnessSessionDiscardedOnExit(ctx) {
+  const { harness, harnessSessionId, stopReason, recentLogLines, supportsDaemonMemoryResume } = ctx;
+  if (!harness || !harnessSessionId) {
+    return false;
+  }
+  if (isCursorSdkRunErrorInLogs(recentLogLines ?? [])) {
+    return true;
+  }
+  if (!supportsDaemonMemoryResume) {
+    return true;
+  }
+  return !shouldRetainHarnessSessionForReconnect(stopReason);
+}
+function notifyNativeHarnessSessionLostOnExit(ctx) {
+  if (!ctx.harness || !ctx.harnessSessionId || !getHarnessCapabilities(ctx.harness).supportsNativeIntegration || !isNativeHarnessSessionDiscardedOnExit(ctx)) {
+    return;
+  }
+  notifyNativeSessionLost({
+    chatroomId: ctx.chatroomId,
+    role: ctx.role,
+    harnessSessionId: ctx.harnessSessionId
+  });
+}
+var init_native_harness_session_exit = __esm(() => {
+  init_types();
+  init_native_task_delivery_coordinator();
+  init_agent_lifecycle();
+});
+
 // src/domain/agent-lifecycle/policies/classify-resume-storm-reason.ts
 function classifyResumeStormReason(logLines) {
   const blob = logLines.join(`
@@ -85209,15 +85589,6 @@ function appendRecentLogLine(slot, line) {
 }
 var RECENT_LOG_LINE_CAP2 = 100;
 
-// src/domain/agent-lifecycle/policies/cursor-sdk-run-error.ts
-function isCursorSdkRunErrorInLogs(logLines) {
-  return logLines.some((line) => line.includes(" run-error]"));
-}
-function formatCursorSdkRunErrorMessage(logLines) {
-  const line = [...logLines].reverse().find((l) => l.includes(" run-error]"));
-  return line?.trim() ?? "Cursor SDK run failed";
-}
-
 // src/domain/agent-lifecycle/use-cases/handle-turn-completed.ts
 async function handleTurnCompleted(deps, input, slot) {
   if (slot?.resumeInFlight) {
@@ -85278,31 +85649,6 @@ var init_handle_turn_completed = __esm(() => {
   init_terminal_provider_error();
 });
 
-// src/infrastructure/services/remote-agents/spawn-prompt.ts
-function createSpawnPrompt(raw, opts) {
-  if (opts?.nativeBootstrap) {
-    return NATIVE_BOOTSTRAP_PROMPT;
-  }
-  const trimmed = raw?.trim();
-  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_TRIGGER_PROMPT;
-}
-var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.", NATIVE_BOOTSTRAP_PROMPT = "Focus on your role responsibilities. Complete each task via handoff.";
-
-// src/domain/native-integration/spawn-policy.ts
-function shouldDeferInitialTurn(harness) {
-  return isNativeHarness(harness);
-}
-function resolveNativeSpawnPolicy(harness, initMessage) {
-  const deferInitialTurn = shouldDeferInitialTurn(harness);
-  return {
-    deferInitialTurn,
-    prompt: createSpawnPrompt(initMessage, { nativeBootstrap: deferInitialTurn })
-  };
-}
-var init_spawn_policy = __esm(() => {
-  init_types();
-});
-
 // src/infrastructure/deps/process.ts
 function isProcessAlive(kill, pid) {
   try {
@@ -85921,6 +86267,15 @@ class AgentProcessManager {
     }
     const stopReason = resolveStopReason(opts.code, opts.signal);
     const ctx = this.captureExitContext(slot, opts, stopReason);
+    notifyNativeHarnessSessionLostOnExit({
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      harness: ctx.harness,
+      harnessSessionId: ctx.harnessSessionId,
+      stopReason: ctx.stopReason,
+      recentLogLines: ctx.recentLogLines,
+      supportsDaemonMemoryResume: Boolean(ctx.harness && this.deps.agentServices.get(ctx.harness)?.resumeFromDaemonMemory)
+    });
     await this.preserveHarnessSessionOnExit(key, slot, ctx);
     const lifecyclePromise = this.lifecycle.runPromise(exports_Effect.gen(function* () {
       const svc = yield* AgentLifecycleService;
@@ -86021,11 +86376,11 @@ class AgentProcessManager {
     }
     this.maybeRestartAgent(opts, ctx);
   }
-  clearHarnessSessionAfterRunError(key, role, recentLogLines) {
+  clearHarnessSessionAfterRunError(key, recentLogLines) {
     if (!isCursorSdkRunErrorInLogs(recentLogLines)) {
       return false;
     }
-    console.log(`[AgentProcessManager] cursor-sdk run-error — cold restarting ${role}: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
+    console.log(`[AgentProcessManager] cursor-sdk run-error — cold restarting ${key}: ${formatCursorSdkRunErrorMessage(recentLogLines)}`);
     this.clearLastHarnessSession(key);
     return true;
   }
@@ -86041,7 +86396,7 @@ class AgentProcessManager {
       this.handlePermanentFailureForRestart(opts, recentLogLines, ctx.terminalProviderFailureHandled);
       return;
     }
-    const coldRestartAfterRunError = this.clearHarnessSessionAfterRunError(key, opts.role, logs);
+    const coldRestartAfterRunError = this.clearHarnessSessionAfterRunError(key, logs);
     this.ensureRunning({
       chatroomId: opts.chatroomId,
       role: opts.role,
@@ -86050,6 +86405,10 @@ class AgentProcessManager {
       workingDir,
       reason: "platform.crash_recovery",
       wantResume: coldRestartAfterRunError ? false : ctx.wantResume ?? true
+    }).then((result) => {
+      if (!result.success) {
+        console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${opts.role}: ${result.error ?? "unknown"}`);
+      }
     }).catch((err) => {
       console.log(`   ⚠️  Failed to restart agent: ${err.message}`);
       this.emitStartFailedEvent(opts.role, opts.chatroomId, err.message);
@@ -86739,6 +87098,7 @@ var init_agent_process_manager = __esm(() => {
   init_turn_completed_backend();
   init_api3();
   init_orphan_tracker();
+  init_native_harness_session_exit();
   init_agent_lifecycle();
   init_abort_resume_storm();
   init_classify_resume_storm_reason();
@@ -86832,7 +87192,7 @@ var init_harness_spawning = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/handlers/daemon-startup-log.ts
-var logStartupEffect = (availableModels) => exports_Effect.gen(function* () {
+var logStartupEffect = (cachedModels) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   yield* exports_Effect.sync(() => {
     console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
@@ -86840,7 +87200,7 @@ var logStartupEffect = (availableModels) => exports_Effect.gen(function* () {
     console.log(`   Machine ID: ${session2.machineId}`);
     console.log(`   Hostname: ${session2.config?.hostname ?? "unknown"}`);
     console.log(`   Available harnesses: ${session2.config?.availableHarnesses.join(", ") || "none"}`);
-    console.log(`   Available models: ${Object.keys(availableModels).length > 0 ? `${Object.values(availableModels).flat().length} models across ${Object.keys(availableModels).join(", ")}` : "none discovered"}`);
+    console.log(`   Available models: ${Object.keys(cachedModels).length > 0 ? `${Object.values(cachedModels).flat().length} cached across ${Object.keys(cachedModels).join(", ")} (refreshing in background)` : "discovering in background"}`);
     console.log(`   PID: ${process.pid}`);
   });
 });
@@ -86852,6 +87212,23 @@ var init_daemon_startup_log = __esm(() => {
 
 // src/commands/machine/daemon-start/init.ts
 import { stat as stat3 } from "node:fs/promises";
+async function discoverModelsForHarness(harness, service3) {
+  const installed2 = await service3.isInstalled();
+  if (!installed2) {
+    return { harness, models: [], installed: false };
+  }
+  try {
+    const models = await service3.listModels();
+    return { harness, models, installed: true };
+  } catch (reason) {
+    console.warn(JSON.stringify({
+      event: "discover-models-error",
+      harness,
+      reason: getErrorMessage(reason)
+    }));
+    return { harness, models: [], installed: true };
+  }
+}
 async function discoverModels(agentServices) {
   return exports_Effect.runPromise(discoverModelsEffect(agentServices));
 }
@@ -86886,6 +87263,51 @@ function createDefaultDeps18() {
     agentProcessManager: null
   };
 }
+function assembleDaemonSessionInit(args2) {
+  const {
+    client: client4,
+    typedSessionId,
+    machineId,
+    config: config3,
+    convexUrl,
+    agentServices,
+    cachedModels,
+    deps
+  } = args2;
+  deps.backend.mutation = (endpoint, args3) => client4.mutation(endpoint, args3);
+  deps.backend.query = (endpoint, args3) => client4.query(endpoint, args3);
+  deps.agentProcessManager = new AgentProcessManager({
+    agentServices,
+    backend: deps.backend,
+    sessionId: typedSessionId,
+    machineId,
+    processes: deps.processes,
+    clock: deps.clock,
+    fs: deps.fs,
+    persistence: deps.machine,
+    spawning: deps.spawning,
+    crashLoop: new CrashLoopTracker,
+    convexUrl
+  });
+  return {
+    client: client4,
+    sessionId: typedSessionId,
+    machineId,
+    config: config3,
+    convexUrl,
+    backend: deps.backend,
+    fs: deps.fs,
+    machine: deps.machine,
+    spawning: deps.spawning,
+    agentProcessManager: deps.agentProcessManager,
+    events: new DaemonEventBus,
+    agentServices,
+    lastPushedGitState: new Map,
+    lastPushedModels: Object.keys(cachedModels).length > 0 ? cachedModels : null,
+    lastPushedHarnessFingerprint: harnessCapabilitiesFingerprint(config3.availableHarnesses, config3.harnessVersions),
+    logger: console
+  };
+}
 
 class NetworkRetryError {
   cause;
@@ -86900,21 +87322,11 @@ async function initDaemon() {
   return exports_Effect.runPromise(initDaemonEffect);
 }
 var discoverModelsEffect = (agentServices) => exports_Effect.gen(function* () {
-  const discoverOne = ([harness, service3]) => exports_Effect.promise(() => service3.isInstalled()).pipe(exports_Effect.flatMap((installed2) => {
-    if (!installed2) {
-      return exports_Effect.succeed(undefined);
+  const discoverOne = ([harness, service3]) => exports_Effect.promise(() => discoverModelsForHarness(harness, service3)).pipe(exports_Effect.map((result) => {
+    if (!result.installed) {
+      return;
     }
-    return exports_Effect.tryPromise({
-      try: () => service3.listModels(),
-      catch: (reason) => reason
-    }).pipe(exports_Effect.map((models) => ({ harness, models })), exports_Effect.catchAll((reason) => {
-      console.warn(JSON.stringify({
-        event: "discover-models-error",
-        harness,
-        reason: getErrorMessage(reason)
-      }));
-      return exports_Effect.succeed({ harness, models: [] });
-    }));
+    return { harness: result.harness, models: result.models };
   }));
   const results = yield* exports_Effect.forEach(Array.from(agentServices.entries()), discoverOne, {
     concurrency: "unbounded"
@@ -87011,21 +87423,28 @@ Run: chatroom auth login`);
     return yield* exports_Effect.die(new Error("Machine config missing after ensureMachineRegistered — this should not happen"));
   }
   return config3;
-}), registerCapabilitiesEffect = (client4, sessionId, config3, agentServices) => exports_Effect.gen(function* () {
+}), registerMachineEffect = (client4, sessionId, config3) => exports_Effect.catchAll(exports_Effect.tryPromise(() => client4.mutation(api.machines.register, {
+  sessionId,
+  machineId: config3.machineId,
+  hostname: config3.hostname,
+  os: config3.os,
+  availableHarnesses: config3.availableHarnesses,
+  harnessVersions: config3.harnessVersions
+})), (error) => exports_Effect.sync(() => {
+  console.warn(`⚠️  Machine registration update failed: ${getErrorMessage(error)}`);
+})), fetchCachedMachineModelsEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
+  try: () => client4.query(api.machines.getMachineModels, { sessionId, machineId }),
+  catch: (e) => e
+}).pipe(exports_Effect.map((result) => result?.availableModels ?? {}), exports_Effect.catchAll(() => exports_Effect.succeed({}))), connectOnceEffect = (client4, sessionId, convexUrl) => exports_Effect.gen(function* () {
+  const typedSessionId = yield* validateSessionEffect(client4, sessionId, convexUrl);
+  const config3 = yield* setupMachineEffect();
   const { machineId } = config3;
-  const availableModels = yield* discoverModelsEffect(agentServices);
-  yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => client4.mutation(api.machines.register, {
-    sessionId,
-    machineId,
-    hostname: config3.hostname,
-    os: config3.os,
-    availableHarnesses: config3.availableHarnesses,
-    harnessVersions: config3.harnessVersions,
-    availableModels
-  })), (error) => exports_Effect.sync(() => {
-    console.warn(`⚠️  Machine registration update failed: ${getErrorMessage(error)}`);
-  }));
-  return availableModels;
+  initHarnessRegistry();
+  const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
+  yield* registerMachineEffect(client4, typedSessionId, config3);
+  const cachedModels = yield* fetchCachedMachineModelsEffect(client4, typedSessionId, machineId);
+  yield* connectDaemonEffect(client4, typedSessionId, machineId);
+  return { typedSessionId, config: config3, machineId, agentServices, cachedModels };
 }), connectDaemonEffect = (client4, sessionId, machineId) => exports_Effect.tryPromise({
   try: () => client4.mutation(api.machines.updateDaemonStatus, {
     sessionId,
@@ -87070,14 +87489,7 @@ Run: chatroom auth login`);
   const attemptRef = yield* exports_Ref.make(0);
   const connectOnce = exports_Effect.gen(function* () {
     yield* exports_Ref.update(attemptRef, (n) => n + 1);
-    const typedSessionId = yield* validateSessionEffect(client4, sessionId, convexUrl);
-    const config3 = yield* setupMachineEffect();
-    const { machineId } = config3;
-    initHarnessRegistry();
-    const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
-    const availableModels = yield* registerCapabilitiesEffect(client4, typedSessionId, config3, agentServices);
-    yield* connectDaemonEffect(client4, typedSessionId, machineId);
-    return { typedSessionId, config: config3, machineId, agentServices, availableModels };
+    return yield* connectOnceEffect(client4, sessionId, convexUrl);
   }).pipe(exports_Effect.catchAll((error) => exports_Effect.flatMap(exports_Ref.get(attemptRef), (currentAttempt) => isNetworkError(error) ? exports_Effect.fail(new NetworkRetryError(error, currentAttempt)) : exports_Effect.die(error))));
   const retrySchedule2 = exports_Schedule.fixed(exports_Duration.millis(CONNECTION_RETRY_INTERVAL_MS));
   const connectWithRetry = connectOnce.pipe(exports_Effect.tapError((retryErr) => exports_Effect.gen(function* () {
@@ -87119,7 +87531,11 @@ var init_init2 = __esm(() => {
   init_spawn_env();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
   initDaemonEffect = exports_Effect.gen(function* () {
-    if (!acquireLock()) {
+    const lockAcquired = yield* exports_Effect.tryPromise({
+      try: () => acquireLockWithRetry(),
+      catch: (e) => e
+    });
+    if (!lockAcquired) {
       return yield* exports_Effect.sync(() => {
         process.exit(1);
       });
@@ -87142,44 +87558,19 @@ var init_init2 = __esm(() => {
       try: () => getConvexClient(),
       catch: (e) => e
     });
-    const { typedSessionId, config: config3, machineId, agentServices, availableModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
-    const deps = createDefaultDeps18();
-    deps.backend.mutation = (endpoint, args2) => client4.mutation(endpoint, args2);
-    deps.backend.query = (endpoint, args2) => client4.query(endpoint, args2);
-    deps.agentProcessManager = new AgentProcessManager({
-      agentServices,
-      backend: deps.backend,
-      sessionId: typedSessionId,
-      machineId,
-      processes: deps.processes,
-      clock: deps.clock,
-      fs: deps.fs,
-      persistence: deps.machine,
-      spawning: deps.spawning,
-      crashLoop: new CrashLoopTracker,
-      convexUrl
-    });
-    const events = new DaemonEventBus;
-    const init2 = {
+    const { typedSessionId, config: config3, machineId, agentServices, cachedModels } = yield* connectWithRetryEffect(client4, sessionId, convexUrl);
+    const init2 = assembleDaemonSessionInit({
       client: client4,
-      sessionId: typedSessionId,
+      typedSessionId,
       machineId,
       config: config3,
       convexUrl,
-      backend: deps.backend,
-      fs: deps.fs,
-      machine: deps.machine,
-      spawning: deps.spawning,
-      agentProcessManager: deps.agentProcessManager,
-      events,
       agentServices,
-      lastPushedGitState: new Map,
-      lastPushedModels: availableModels,
-      lastPushedHarnessFingerprint: harnessCapabilitiesFingerprint(config3.availableHarnesses, config3.harnessVersions),
-      logger: console
-    };
+      cachedModels,
+      deps: createDefaultDeps18()
+    });
     yield* registerEventListenersEffect().pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
-    yield* logStartupEffect(availableModels).pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
+    yield* logStartupEffect(cachedModels).pipe(exports_Effect.provide(daemonSessionToLayers(init2)));
     yield* recoverStateEffect(init2);
     return init2;
   });
@@ -87229,7 +87620,70 @@ function logRefreshOutcome(diff8, totalCount) {
   const summary5 = totalCount > 0 ? `${totalCount} models` : "none discovered";
   console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh pushed: ${summary5}`);
 }
-var refreshModelsEffect;
+function logPushOutcome(modelDiff, totalCount, options) {
+  if (options?.logPrefix) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 ${options.logPrefix}: ${totalCount > 0 ? `${totalCount} models` : "none discovered"}`);
+    return;
+  }
+  logRefreshOutcome(modelDiff, totalCount);
+}
+var pushModelsSnapshotMutationEffect = (models, modelDiff, nextHarnessFingerprint, ctxConfig, options) => exports_Effect.gen(function* () {
+  const session2 = yield* DaemonSessionService;
+  yield* exports_Effect.tryPromise({
+    try: async () => session2.backend.mutation(api.machines.refreshCapabilities, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      availableHarnesses: ctxConfig.availableHarnesses,
+      harnessVersions: ctxConfig.harnessVersions,
+      availableModels: models
+    }),
+    catch: (e) => e
+  });
+  const totalCount = Object.values(models).flat().length;
+  logPushOutcome(modelDiff, totalCount, options);
+  return {
+    kind: "pushed",
+    snapshot: {
+      lastPushedModels: models,
+      lastPushedHarnessFingerprint: nextHarnessFingerprint
+    }
+  };
+}), pushModelsSnapshotIfChangedEffect = (models, options) => exports_Effect.gen(function* () {
+  const session2 = yield* DaemonSessionService;
+  const mutable = yield* DaemonMutableStateService;
+  if (!session2.config) {
+    return { kind: "skipped_no_changes" };
+  }
+  const lastPushedModels = yield* exports_Ref.get(mutable.lastPushedModels);
+  const lastPushedHarnessFingerprint = yield* exports_Ref.get(mutable.lastPushedHarnessFingerprint);
+  const modelDiff = diffModels(lastPushedModels, models);
+  const nextHarnessFingerprint = harnessCapabilitiesFingerprint(session2.config.availableHarnesses, session2.config.harnessVersions);
+  if (!modelDiff.hasChanges && !harnessFingerprintChanged(lastPushedHarnessFingerprint, nextHarnessFingerprint)) {
+    return { kind: "skipped_no_changes" };
+  }
+  return yield* pushModelsSnapshotMutationEffect(models, modelDiff, nextHarnessFingerprint, session2.config, options);
+}).pipe(exports_Effect.catchAll((error) => exports_Effect.sync(() => {
+  const message = getErrorMessage(error);
+  console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${message}`);
+  return { kind: "failed", message };
+}))), refreshModelsEffect, discoverAndPushHarnessModelsEffect = (harness, service3) => exports_Effect.gen(function* () {
+  const mutable = yield* DaemonMutableStateService;
+  const result = yield* exports_Effect.promise(() => discoverModelsForHarness(harness, service3));
+  const current = (yield* exports_Ref.get(mutable.lastPushedModels)) ?? {};
+  const next4 = { ...current };
+  if (result.installed) {
+    next4[harness] = result.models;
+  } else {
+    delete next4[harness];
+  }
+  const pushOutcome = yield* pushModelsSnapshotIfChangedEffect(next4, {
+    logPrefix: `${harness} models updated`
+  });
+  if (pushOutcome.kind === "pushed") {
+    yield* exports_Ref.set(mutable.lastPushedModels, pushOutcome.snapshot.lastPushedModels);
+    yield* exports_Ref.set(mutable.lastPushedHarnessFingerprint, pushOutcome.snapshot.lastPushedHarnessFingerprint);
+  }
+}), startBackgroundModelDiscoveryEffect;
 var init_models_refresh = __esm(() => {
   init_esm();
   init_daemon_services();
@@ -87244,8 +87698,6 @@ var init_models_refresh = __esm(() => {
       return { kind: "noop" };
     }
     const ctxConfig = session2.config;
-    const lastPushedModels = yield* exports_Ref.get(mutable.lastPushedModels);
-    const lastPushedHarnessFingerprint = yield* exports_Ref.get(mutable.lastPushedHarnessFingerprint);
     const outcome = yield* exports_Effect.gen(function* () {
       const models = yield* exports_Effect.tryPromise({
         try: async () => discoverModels(session2.agentServices),
@@ -87257,31 +87709,7 @@ var init_models_refresh = __esm(() => {
       });
       ctxConfig.availableHarnesses = freshConfig.availableHarnesses;
       ctxConfig.harnessVersions = freshConfig.harnessVersions;
-      const modelDiff = diffModels(lastPushedModels, models);
-      const nextHarnessFingerprint = harnessCapabilitiesFingerprint(ctxConfig.availableHarnesses, ctxConfig.harnessVersions);
-      const fingerprintChanged = harnessFingerprintChanged(lastPushedHarnessFingerprint, nextHarnessFingerprint);
-      if (!modelDiff.hasChanges && !fingerprintChanged) {
-        return { kind: "skipped_no_changes" };
-      }
-      const totalCount = Object.values(models).flat().length;
-      yield* exports_Effect.tryPromise({
-        try: async () => session2.backend.mutation(api.machines.refreshCapabilities, {
-          sessionId: session2.sessionId,
-          machineId: session2.machineId,
-          availableHarnesses: ctxConfig.availableHarnesses,
-          harnessVersions: ctxConfig.harnessVersions,
-          availableModels: models
-        }),
-        catch: (e) => e
-      });
-      logRefreshOutcome(modelDiff, totalCount);
-      return {
-        kind: "pushed",
-        snapshot: {
-          lastPushedModels: models,
-          lastPushedHarnessFingerprint: nextHarnessFingerprint
-        }
-      };
+      return yield* pushModelsSnapshotIfChangedEffect(models);
     }).pipe(exports_Effect.catchAll((error) => exports_Effect.sync(() => {
       const message = getErrorMessage(error);
       console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${message}`);
@@ -87290,9 +87718,22 @@ var init_models_refresh = __esm(() => {
     if (outcome.kind === "pushed") {
       yield* exports_Ref.set(mutable.lastPushedModels, outcome.snapshot.lastPushedModels);
       yield* exports_Ref.set(mutable.lastPushedHarnessFingerprint, outcome.snapshot.lastPushedHarnessFingerprint);
+      return {
+        kind: "pushed",
+        snapshot: outcome.snapshot
+      };
+    }
+    if (outcome.kind === "skipped_no_changes") {
+      return { kind: "skipped_no_changes" };
     }
     return outcome;
   });
+  startBackgroundModelDiscoveryEffect = exports_Effect.gen(function* () {
+    const session2 = yield* DaemonSessionService;
+    if (!session2.config)
+      return;
+    yield* exports_Effect.forEach(Array.from(session2.agentServices.entries()), ([harness, service3]) => discoverAndPushHarnessModelsEffect(harness, service3), { concurrency: "unbounded" });
+  });
 });
 
 // src/commands/machine/daemon-start/observed-sync.ts
@@ -87489,225 +87930,6 @@ var init_observed_sync = __esm(() => {
   init_convex_error();
 });
 
-// ../../services/backend/src/domain/handoff/parse-compress-context.ts
-function findSectionIndex(content, headings) {
-  const indices = headings.map((heading) => content.indexOf(heading)).filter((idx) => idx !== -1);
-  return indices.length === 0 ? -1 : Math.min(...indices);
-}
-function normalizeMode(raw) {
-  const value = raw.toLowerCase();
-  if (value === "reset")
-    return "new_session";
-  if (value === "none")
-    return value;
-  return DEFAULT_MODE;
-}
-function extractSectionBody(content, sectionIdx) {
-  const matchedHeading = SECTION_HEADINGS.find((h) => content.indexOf(h, sectionIdx) === sectionIdx) ?? SECTION_HEADINGS[0];
-  const afterSection = content.slice(sectionIdx);
-  const nextHeading = afterSection.slice(matchedHeading.length).search(/\n## /);
-  return nextHeading === -1 ? afterSection : afterSection.slice(0, matchedHeading.length + nextHeading);
-}
-function parseCompressContext(handoffContent) {
-  const sectionIdx = findSectionIndex(handoffContent, SECTION_HEADINGS);
-  if (sectionIdx === -1)
-    return DEFAULT_MODE;
-  const match17 = extractSectionBody(handoffContent, sectionIdx).match(DATA_TAG);
-  if (!match17)
-    return DEFAULT_MODE;
-  return normalizeMode(match17[1]);
-}
-function compressContextToWantResume(mode) {
-  return mode === "none";
-}
-var SECTION_HEADINGS, DATA_TAG, DEFAULT_MODE = "new_session";
-var init_parse_compress_context = __esm(() => {
-  SECTION_HEADINGS = ["## Session Management", "## Restart new context"];
-  DATA_TAG = /\/\/\s*data:agent\.compress_context=(new_session|reset|none)\b/i;
-});
-
-// src/domain/native-integration/predicates.ts
-function isNativePendingAliveRunning(task) {
-  const { agentConfig, status: status3 } = task;
-  return isNativeHarness(agentConfig.agentHarness) && status3 === "pending" && agentConfig.spawnedAgentPid != null && agentConfig.desiredState === "running";
-}
-function isNativeInjectableAliveRunning(task) {
-  const { agentConfig, status: status3 } = task;
-  if (!isNativeHarness(agentConfig.agentHarness))
-    return false;
-  if (agentConfig.spawnedAgentPid == null || agentConfig.desiredState !== "running") {
-    return false;
-  }
-  if (status3 === "pending")
-    return true;
-  if (status3 === "acknowledged") {
-    const assignedTo = task.assignedTo?.toLowerCase();
-    return assignedTo === agentConfig.role.toLowerCase();
-  }
-  return false;
-}
-function isInjectableNativeAction(action) {
-  if (action == null)
-    return true;
-  return action === NATIVE_WAITING_ACTION;
-}
-function isNativeIdleAfterTaskComplete(participant) {
-  return participant.lastSeenAction === NATIVE_TASK_INJECTED_ACTION && participant.lastStatus === "task.completed";
-}
-function isNativeAcknowledgedInjectionRetry(task) {
-  if (task.status !== "acknowledged")
-    return false;
-  const assignedTo = task.assignedTo?.toLowerCase();
-  if (assignedTo !== task.agentConfig.role.toLowerCase())
-    return false;
-  return task.participant?.lastSeenAction === NATIVE_TASK_INJECTED_ACTION;
-}
-function isStaleCliGetNextTaskWaiting(task) {
-  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
-  return task.participant?.lastSeenAction === "get-next-task:started" && task.createdAt > lastSeenAt;
-}
-function isCliIdleNotListening(task, now, thresholdMs) {
-  const lastSeenAt = task.participant?.lastSeenAt ?? 0;
-  if (lastSeenAt === 0)
-    return now - task.createdAt > thresholdMs;
-  return now - lastSeenAt > thresholdMs;
-}
-var init_predicates = __esm(() => {
-  init_types();
-  init_participant();
-});
-
-// src/domain/native-integration/index.ts
-var init_native_integration = __esm(() => {
-  init_types();
-  init_predicates();
-  init_spawn_policy();
-});
-
-// src/commands/machine/daemon-start/native-task-injector-logic.ts
-function shouldInjectNativeTask(task, opts) {
-  if (!isNativeInjectableAliveRunning(task))
-    return false;
-  if (opts?.alreadyInjectedTaskIds?.has(task.taskId))
-    return false;
-  return isInjectableNativeAction(task.participant?.lastSeenAction) || isNativeIdleAfterTaskComplete(task.participant ?? {}) || isNativeAcknowledgedInjectionRetry(task);
-}
-function buildNativeInjectionPrompt(params) {
-  const { taskDeliveryOutput, compressMode } = params;
-  if (compressMode === "new_session") {
-    return [
-      "⚠️ Context was compacted. Run `chatroom get-system-prompt` only if role instructions are missing.",
-      "",
-      taskDeliveryOutput
-    ].join(`
-`);
-  }
-  return taskDeliveryOutput;
-}
-
-class NativeInjectionDedup {
-  injected = new Set;
-  inFlight = new Set;
-  tryAcquire(taskId) {
-    if (this.has(taskId) || this.inFlight.has(taskId)) {
-      return false;
-    }
-    this.inFlight.add(taskId);
-    return true;
-  }
-  markInjected(taskId) {
-    this.inFlight.delete(taskId);
-    this.injected.add(taskId);
-  }
-  has(taskId) {
-    return this.injected.has(taskId);
-  }
-  clear(taskId) {
-    this.inFlight.delete(taskId);
-    this.injected.delete(taskId);
-  }
-}
-var init_native_task_injector_logic = __esm(() => {
-  init_predicates();
-  init_native_integration();
-});
-
-// src/commands/machine/daemon-start/native-task-injector.ts
-function runNativeInjectionEffect(task, deps, dedup) {
-  return exports_Effect.gen(function* () {
-    if (!shouldInjectNativeTask(task, { alreadyInjectedTaskIds: dedup })) {
-      return;
-    }
-    const { chatroomId, taskId, taskContent, agentConfig, status: status3 } = task;
-    const { role } = agentConfig;
-    if (!dedup.tryAcquire(taskId)) {
-      return;
-    }
-    if (status3 === "pending") {
-      const claimResult = yield* exports_Effect.tryPromise({
-        try: () => deps.backend.mutation(api.tasks.claimTask, {
-          sessionId: deps.sessionId,
-          chatroomId,
-          role,
-          taskId
-        }),
-        catch: (err) => err
-      }).pipe(exports_Effect.either);
-      if (claimResult._tag === "Left") {
-        dedup.clear(taskId);
-        return yield* exports_Effect.fail(claimResult.left);
-      }
-    }
-    const deliveryResult = yield* exports_Effect.tryPromise({
-      try: () => deps.backend.query(api.messages.getTaskDeliveryPrompt, {
-        sessionId: deps.sessionId,
-        chatroomId,
-        role,
-        taskId,
-        convexUrl: deps.convexUrl
-      }),
-      catch: (err) => err
-    }).pipe(exports_Effect.either);
-    if (deliveryResult._tag === "Left") {
-      dedup.clear(taskId);
-      return yield* exports_Effect.fail(deliveryResult.left);
-    }
-    const delivery = deliveryResult.right;
-    const prompt = buildNativeInjectionPrompt({
-      taskDeliveryOutput: delivery.fullCliOutput,
-      compressMode: parseCompressContext(taskContent)
-    });
-    yield* exports_Effect.tryPromise({
-      try: () => deps.backend.mutation(api.participants.join, {
-        sessionId: deps.sessionId,
-        chatroomId,
-        role,
-        action: NATIVE_TASK_INJECTED_ACTION,
-        taskId
-      }),
-      catch: (err) => err
-    }).pipe(exports_Effect.tapError(() => exports_Effect.sync(() => dedup.clear(taskId))));
-    const resumeResult = yield* exports_Effect.tryPromise({
-      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
-      catch: (err) => err
-    }).pipe(exports_Effect.either);
-    if (resumeResult._tag === "Left") {
-      dedup.clear(taskId);
-      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${getErrorMessage(resumeResult.left)}`);
-      return;
-    }
-    dedup.markInjected(taskId);
-  });
-}
-var init_native_task_injector = __esm(() => {
-  init_participant();
-  init_parse_compress_context();
-  init_esm();
-  init_native_task_injector_logic();
-  init_api3();
-  init_convex_error();
-});
-
 // src/commands/machine/daemon-start/task-monitor-logic.ts
 function isPendingAliveRunningTask(task) {
   const { agentConfig, status: status3 } = task;
@@ -87722,18 +87944,38 @@ function isSlotUnavailableForPid(slot, pid, isPidAlive) {
   }
   return !isPidAlive(pid);
 }
-function isNativeAgentLocallyUnavailable(task, health) {
-  if (!isNativePendingAliveRunning(task))
-    return false;
-  const pid = task.agentConfig.spawnedAgentPid;
-  if (pid == null)
-    return false;
+function isNativeRevivableTaskStatus(task) {
+  const { status: status3 } = task;
+  if (status3 === "pending") {
+    return task.agentConfig.spawnedAgentPid != null;
+  }
+  if (status3 === "acknowledged") {
+    return task.assignedTo?.toLowerCase() === task.agentConfig.role.toLowerCase();
+  }
+  return false;
+}
+function isNativeAgentSlotDown(task, health) {
   const slot = health.getSlot(task.chatroomId, task.agentConfig.role);
+  if (slot?.state === "spawning")
+    return false;
+  const pid = task.agentConfig.spawnedAgentPid ?? slot?.pid;
+  if (pid == null) {
+    return slot?.state !== "running";
+  }
   return isSlotUnavailableForPid(slot, pid, health.isPidAlive);
 }
+function isNativeActiveTaskAgentDown(task, health) {
+  if (!isNativeHarness(task.agentConfig.agentHarness))
+    return false;
+  if (task.agentConfig.desiredState !== "running")
+    return false;
+  if (!isNativeRevivableTaskStatus(task))
+    return false;
+  return isNativeAgentSlotDown(task, health);
+}
 function listNativeTasksNeedingRevive(tasks, health, now, cooldown) {
   return tasks.filter((task) => {
-    if (!isNativeAgentLocallyUnavailable(task, health))
+    if (!isNativeActiveTaskAgentDown(task, health))
       return false;
     const { chatroomId, agentConfig } = task;
     if (!agentConfig.workingDir)
@@ -87799,16 +88041,6 @@ var init_task_monitor_logic = __esm(() => {
 function resolveTaskWantResume(task) {
   return compressContextToWantResume(parseCompressContext(task.taskContent ?? ""));
 }
-function runNativeInjectionFork(task, runtime4, effectContext2, dedup, agentMgr, session2) {
-  exports_Runtime.runFork(runtime4)(runNativeInjectionEffect(task, {
-    sessionId: session2.sessionId,
-    backend: session2.backend,
-    agentMgr: {
-      resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
-    },
-    convexUrl: session2.convexUrl
-  }, dedup).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native injection failed for ${task.agentConfig.role}@${task.chatroomId}: ${getErrorMessage(err)}`)))));
-}
 function buildCliNudgeLogLine(task) {
   const { chatroomId, agentConfig } = task;
   const { role } = agentConfig;
@@ -87817,13 +88049,25 @@ function buildCliNudgeLogLine(task) {
   const wantResume = resolveTaskWantResume(task);
   return `[TaskMonitor] nudging ${role}@${chatroomId} — pending task ${task.taskId}, lastSeenAction=${lastSeenAction}, compress_context=${compressMode}, wantResume=${wantResume}`;
 }
-function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
+function resolveTaskRunnerContext(task) {
   const { chatroomId, agentConfig } = task;
   const { role } = agentConfig;
   const workingDir = agentConfig.workingDir;
   if (!workingDir)
     return;
-  const wantResume = resolveTaskWantResume(task);
+  return {
+    chatroomId,
+    agentConfig,
+    role,
+    workingDir,
+    wantResume: resolveTaskWantResume(task)
+  };
+}
+function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
+  const ctx = resolveTaskRunnerContext(task);
+  if (!ctx)
+    return;
+  const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.stop({ chatroomId, role, reason: "platform.task_monitor_nudge" });
     yield* agentMgr.ensureRunning({
@@ -87838,12 +88082,10 @@ function executeCliNudge(task, runtime4, effectContext2, agentMgr) {
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] nudge failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
 function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
-  const { chatroomId, agentConfig } = task;
-  const { role } = agentConfig;
-  const workingDir = agentConfig.workingDir;
-  if (!workingDir)
+  const ctx = resolveTaskRunnerContext(task);
+  if (!ctx)
     return;
-  const wantResume = resolveTaskWantResume(task);
+  const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
   console.log(`[TaskMonitor] native revive ${role}@${chatroomId} — backend PID stale or missing locally for pending task ${task.taskId}`);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.ensureRunning({
@@ -87871,21 +88113,20 @@ function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectCo
     runNativeReviveEffect(task, runtime4, effectContext2, agentMgr);
   }
 }
-function injectNativeTasks(tasks, runtime4, effectContext2, dedup, agentMgr, sessionDeps) {
-  for (const task of tasks) {
-    if (shouldInjectNativeTask(task, { alreadyInjectedTaskIds: dedup })) {
-      runNativeInjectionFork(task, runtime4, effectContext2, dedup, agentMgr, sessionDeps);
-    }
-  }
-}
-function processTasksUpdate(tasks, runtime4, effectContext2, dedup, cooldown, agentMgr, sessionDeps) {
+function processTasksUpdate(tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps) {
   const now = Date.now();
   const localHealth = {
     getSlot: (chatroomId, role) => agentMgr.getSlot(chatroomId, role),
     isPidAlive: (pid) => isProcessAlive((p) => process.kill(p, 0), pid)
   };
   reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr);
-  injectNativeTasks(tasks, runtime4, effectContext2, dedup, agentMgr, sessionDeps);
+  getNativeTaskDeliveryCoordinator().reconcileAssignedTasks({
+    tasks,
+    runtime: runtime4,
+    effectContext: effectContext2,
+    agentMgr,
+    sessionDeps
+  });
   nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr);
 }
 var startTaskMonitorSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
@@ -87895,7 +88136,6 @@ var startTaskMonitorSubscriptionEffect = (wsClient2) => exports_Effect.gen(funct
   const runtime4 = yield* exports_Effect.runtime();
   console.log(`[${formatTimestamp()}] \uD83D\uDCCB Starting task-monitor subscription (reactive)`);
   const cooldown = new NudgeCooldown;
-  const dedup = new NativeInjectionDedup;
   let stopped = false;
   const sessionDeps = {
     sessionId: session2.sessionId,
@@ -87908,7 +88148,7 @@ var startTaskMonitorSubscriptionEffect = (wsClient2) => exports_Effect.gen(funct
   const onTasksUpdate = (result) => {
     if (stopped || !result?.tasks?.length)
       return;
-    processTasksUpdate(result.tasks, runtime4, effectContext2, dedup, cooldown, agentMgr, sessionDeps);
+    processTasksUpdate(result.tasks, runtime4, effectContext2, cooldown, agentMgr, sessionDeps);
   };
   const unsubscribe = wsClient2.onUpdate(api.machines.getAssignedTasks, { sessionId: session2.sessionId, machineId: session2.machineId }, onTasksUpdate, (err) => console.warn(`[${formatTimestamp()}] Task-monitor subscription error: ${getErrorMessage(err)}`));
   return {
@@ -87923,8 +88163,7 @@ var init_task_monitor = __esm(() => {
   init_parse_compress_context();
   init_esm();
   init_daemon_services();
-  init_native_task_injector_logic();
-  init_native_task_injector();
+  init_native_task_delivery_coordinator();
   init_task_monitor_logic();
   init_api3();
   init_convex_error();
@@ -88362,13 +88601,16 @@ Listening for commands...`);
 // src/commands/machine/daemon-start/index.ts
 async function daemonStart() {
   const init2 = await initDaemon();
-  await exports_Effect.runPromise(startCommandLoopEffect.pipe(exports_Effect.provide(daemonSessionToLayers(init2))));
+  const layers = daemonSessionToLayers(init2);
+  exports_Effect.runFork(startBackgroundModelDiscoveryEffect.pipe(exports_Effect.provide(layers)));
+  await exports_Effect.runPromise(startCommandLoopEffect.pipe(exports_Effect.provide(layers)));
 }
 var init_daemon_start = __esm(() => {
   init_esm();
   init_command_loop();
   init_daemon_layers();
   init_init2();
+  init_models_refresh();
 });
 
 // src/commands/machine/daemon-stop.ts
@@ -89423,4 +89665,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=0ABED035EA994A7864756E2164756E21
+//# debugId=CFDE8D88B080E55664756E2164756E21