chatroom-cli 1.53.1 → 1.53.3

package/dist/index.js

@@ -28015,7 +28015,7 @@ ${options.prompt}` : options.prompt;
           process.stderr.write(`${logPrefix} spawn-error] ${reason}
 `);
         } finally {
-          if (!session.agentClosed && !session.preserveForResume) {
+          if (!session.agentClosed && session.aborted && !session.preserveForResume) {
             try {
               agent.close();
               session.agentClosed = true;
@@ -79715,9 +79715,11 @@ var init_featureFlags = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000;
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS;
 var init_reliability = __esm(() => {
   OBSERVED_FULL_PUSH_INTERVAL_MS = 5 * 60000;
+  WORKSPACE_RECENCY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+  WORKSPACE_LIST_RECONCILE_MS = 60 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/capabilities-snapshot.ts
@@ -79987,34 +79989,30 @@ var init_command_discovery = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/workspace-cache.ts
-function invalidateWorkspacesForMachineCache(ctx) {
-  delete ctx._workspacesCache;
-}
 async function getWorkspacesForMachine(ctx) {
-  const extended = ctx;
-  const now = Date.now();
-  const cached4 = extended._workspacesCache;
-  if (cached4 && now - cached4.fetchedAt < CACHE_TTL_MS) {
-    return cached4.workspaces;
+  const store = ctx.workspaceListStore;
+  if (store && store.updatedAt > 0) {
+    return store.workspaces;
   }
   try {
-    const workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
+    const workspaces = await ctx.deps.backend.query(api.workspaces.listRecentlyObservedWorkspacesForMachine, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     });
-    extended._workspacesCache = { fetchedAt: now, workspaces };
-    return workspaces;
+    const mapped = workspaces.map((ws) => ({ workingDir: ws.workingDir }));
+    if (store) {
+      store.workspaces = mapped;
+      store.updatedAt = Date.now();
+    }
+    return mapped;
   } catch (err) {
     console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces: ${getErrorMessage(err)}`);
     return [];
   }
 }
-var CACHE_TTL_MS;
 var init_workspace_cache = __esm(() => {
-  init_reliability();
   init_api3();
   init_convex_error();
-  CACHE_TTL_MS = DAEMON_HEARTBEAT_INTERVAL_MS;
 });
 
 // src/commands/machine/daemon-start/command-sync-heartbeat.ts
@@ -83159,7 +83157,45 @@ var init_output_store = __esm(() => {
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
-// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+// src/commands/machine/daemon-start/handlers/process/log-observer-subscription.ts
+function setsEqual(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const id3 of a) {
+    if (!b.has(id3))
+      return false;
+  }
+  return true;
+}
+function formatRunIdShort(runId) {
+  return runId.length > 8 ? `${runId.slice(0, 8)}…` : runId;
+}
+function logObserverSetChangeIfNeeded(runs) {
+  const nextObserved = new Set;
+  const nextPending = new Set;
+  for (const run3 of runs) {
+    nextObserved.add(run3._id);
+    if (run3.pendingFullOutputSync) {
+      nextPending.add(run3._id);
+    }
+  }
+  if (setsEqual(observedRunIds, nextObserved) && setsEqual(pendingFullSyncRunIds, nextPending)) {
+    return;
+  }
+  const runSummaries = [...nextObserved].map(formatRunIdShort).join(", ") || "none";
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log observers updated: ${nextObserved.size} run(s) [${runSummaries}] pendingFull=${nextPending.size}`);
+}
+function applyObservedRuns(runs) {
+  logObserverSetChangeIfNeeded(runs);
+  observedRunIds.clear();
+  pendingFullSyncRunIds.clear();
+  for (const run3 of runs) {
+    observedRunIds.add(run3._id);
+    if (run3.pendingFullOutputSync) {
+      pendingFullSyncRunIds.add(run3._id);
+    }
+  }
+}
 function isRunLogObserved(runId) {
   return observedRunIds.has(runId);
 }
@@ -83169,77 +83205,41 @@ function consumePendingFullSync(runId) {
   pendingFullSyncRunIds.delete(runId);
   return true;
 }
-function startLogObserverPoll(ctx) {
+function startLogObserverSubscription(ctx, wsClient2) {
+  const queryArgs = {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  };
   let stopped = false;
-  let consecutiveIdlePolls = 0;
-  let pollInFlight = false;
-  let timeoutHandle = null;
-  const scheduleNext = (delayMs) => {
+  const unsubscribe = wsClient2.onUpdate(api.daemon.commands.listRunsWithLogObservers, queryArgs, (runs) => {
     if (stopped)
       return;
-    if (timeoutHandle)
-      clearTimeout(timeoutHandle);
-    timeoutHandle = setTimeout(() => {
-      poll4();
-    }, delayMs);
-    timeoutHandle.unref?.();
-  };
-  const poll4 = async () => {
-    if (stopped || pollInFlight)
-      return;
-    const hasLocalObservers = observedRunIds.size > 0;
-    if (!hasLocalObservers && consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE) {
-      scheduleNext(IDLE_POLL_INTERVAL_MS);
-      return;
-    }
-    pollInFlight = true;
-    try {
-      const runs = await ctx.deps.backend.query(api.commands.listRunsWithLogObservers, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId
-      });
-      observedRunIds.clear();
-      pendingFullSyncRunIds.clear();
-      for (const run3 of runs) {
-        observedRunIds.add(run3._id);
-        if (run3.pendingFullOutputSync) {
-          pendingFullSyncRunIds.add(run3._id);
-        }
-      }
-      const isActive2 = runs.length > 0 || hasLocalObservers;
-      if (isActive2) {
-        consecutiveIdlePolls = 0;
-        scheduleNext(ACTIVE_POLL_INTERVAL_MS);
-      } else {
-        consecutiveIdlePolls++;
-        scheduleNext(consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE ? IDLE_POLL_INTERVAL_MS : ACTIVE_POLL_INTERVAL_MS);
-      }
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Log-observer poll failed: ${getErrorMessage(err)}`);
-      scheduleNext(ACTIVE_POLL_INTERVAL_MS);
-    } finally {
-      pollInFlight = false;
-    }
-  };
-  poll4();
+    applyObservedRuns(runs ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Log-observer subscription error: ${getErrorMessage(err)}`);
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log-observer subscription started`);
   return {
     stop: () => {
       stopped = true;
-      if (timeoutHandle)
-        clearTimeout(timeoutHandle);
+      unsubscribe();
       observedRunIds.clear();
       pendingFullSyncRunIds.clear();
+      console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log-observer subscription stopped`);
     }
   };
 }
-var observedRunIds, pendingFullSyncRunIds, ACTIVE_POLL_INTERVAL_MS, IDLE_POLL_INTERVAL_MS = 15000, IDLE_SKIP_AFTER_CONSECUTIVE = 3;
-var init_log_observer_sync = __esm(() => {
+var observedRunIds, pendingFullSyncRunIds;
+var init_log_observer_subscription = __esm(() => {
   init_api3();
   init_convex_error();
-  init_state2();
   observedRunIds = new Set;
   pendingFullSyncRunIds = new Set;
-  ACTIVE_POLL_INTERVAL_MS = OUTPUT_FLUSH_INTERVAL_MS;
+});
+
+// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+var init_log_observer_sync = __esm(() => {
+  init_log_observer_subscription();
 });
 
 // src/commands/machine/daemon-start/handlers/process/spawner.ts
@@ -83819,7 +83819,7 @@ function isProcessAlive(kill, pid) {
   }
 }
 
-// src/infrastructure/machine/stop-reason.ts
+// src/domain/agent-lifecycle/entities/stop-reason.ts
 function resolveStopReason(code2, signal) {
   if (signal !== null)
     return "agent_process.signal";
@@ -83828,11 +83828,59 @@ function resolveStopReason(code2, signal) {
   return "agent_process.crashed";
 }
 
+// src/domain/agent-lifecycle/policies/preserve-session.ts
+function shouldRetainHarnessSessionForReconnect(reason) {
+  switch (reason) {
+    case "user.stop":
+    case "agent_process.exited_clean":
+    case "agent_process.signal":
+    case "agent_process.crashed":
+      return true;
+    default:
+      return false;
+  }
+}
+function shouldPreserveHarnessTeardown(reason, supportsSessionResume, hasHarnessSessionId) {
+  return hasHarnessSessionId && supportsSessionResume && shouldRetainHarnessSessionForReconnect(reason);
+}
+
+// src/domain/agent-lifecycle/policies/decide-resume-path.ts
+function decideResumePathOnRestart(input) {
+  if (!input.supportsSessionResume) {
+    return "cold";
+  }
+  if (input.wantResume && input.hasStoredSnapshot) {
+    return "daemon_memory";
+  }
+  return "cold";
+}
+function shouldAutoRestartAfterProcessExit(stopReason) {
+  switch (stopReason) {
+    case "user.stop":
+    case "platform.team_switch":
+    case "daemon.shutdown":
+    case "daemon.respawn":
+      return false;
+    default:
+      return true;
+  }
+}
+
+// src/domain/agent-lifecycle/index.ts
+var init_agent_lifecycle = () => {};
+
 // ../../services/backend/src/domain/entities/harness/claude.config.ts
 var claudeCapabilities;
 var init_claude_config = __esm(() => {
   claudeCapabilities = {
-    supportsSessionResume: false
+    runtimeKind: "cli",
+    supportsSessionResume: false,
+    lifecycle: {
+      turnCompleted: false,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: []
   };
 });
 
@@ -83840,7 +83888,14 @@ var init_claude_config = __esm(() => {
 var commandcodeCapabilities;
 var init_commandcode_config = __esm(() => {
   commandcodeCapabilities = {
-    supportsSessionResume: false
+    runtimeKind: "cli",
+    supportsSessionResume: false,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["wire.log.agent_end"]
   };
 });
 
@@ -83848,7 +83903,14 @@ var init_commandcode_config = __esm(() => {
 var copilotCapabilities;
 var init_copilot_config = __esm(() => {
   copilotCapabilities = {
-    supportsSessionResume: false
+    runtimeKind: "cli",
+    supportsSessionResume: false,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["wire.log.agent_end"]
   };
 });
 
@@ -83856,7 +83918,14 @@ var init_copilot_config = __esm(() => {
 var cursorCapabilities;
 var init_cursor_config = __esm(() => {
   cursorCapabilities = {
-    supportsSessionResume: false
+    runtimeKind: "cli",
+    supportsSessionResume: false,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["wire.log.agent_end"]
   };
 });
 
@@ -83864,7 +83933,14 @@ var init_cursor_config = __esm(() => {
 var cursorSdkCapabilities;
 var init_cursor_sdk_config = __esm(() => {
   cursorSdkCapabilities = {
-    supportsSessionResume: true
+    runtimeKind: "sdk",
+    supportsSessionResume: true,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["sdk.cursor.message", "sdk.cursor.run.completed", "wire.log.agent_end"]
   };
 });
 
@@ -83872,7 +83948,14 @@ var init_cursor_sdk_config = __esm(() => {
 var opencodeCapabilities;
 var init_opencode_config = __esm(() => {
   opencodeCapabilities = {
-    supportsSessionResume: false
+    runtimeKind: "cli",
+    supportsSessionResume: false,
+    lifecycle: {
+      turnCompleted: false,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: []
   };
 });
 
@@ -83880,7 +83963,14 @@ var init_opencode_config = __esm(() => {
 var opencodeSdkCapabilities;
 var init_opencode_sdk_config = __esm(() => {
   opencodeSdkCapabilities = {
-    supportsSessionResume: true
+    runtimeKind: "sdk",
+    supportsSessionResume: true,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: ["sdk.opencode.session.idle", "sdk.opencode.session.event"]
   };
 });
 
@@ -83888,7 +83978,22 @@ var init_opencode_sdk_config = __esm(() => {
 var piCapabilities;
 var init_pi_config = __esm(() => {
   piCapabilities = {
-    supportsSessionResume: true
+    runtimeKind: "cli",
+    supportsSessionResume: true,
+    lifecycle: {
+      turnCompleted: true,
+      outputActivity: true,
+      processExited: true
+    },
+    wireEvents: [
+      "wire.ndjson.agent_start",
+      "wire.ndjson.agent_end",
+      "wire.ndjson.message_update",
+      "wire.ndjson.tool_execution_start",
+      "wire.ndjson.tool_execution_end",
+      "wire.ndjson.get_state",
+      "wire.log.agent_end"
+    ]
   };
 });
 
@@ -84010,11 +84115,11 @@ class AgentProcessManager {
     const key = agentKey2(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
     if (slot?.resumeInFlight) {
-      console.log(`[AgentProcessManager] agent_end: skipping duplicate resume for ${opts.role} (resume already in flight)`);
+      console.log(`[AgentProcessManager] lifecycle.turn.completed: skipping duplicate resume for ${opts.role} (resume already in flight)`);
       return;
     }
     const capabilities = getHarnessCapabilities(opts.harness);
-    console.log(`[AgentProcessManager] agent_end: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${capabilities.supportsSessionResume}`);
+    console.log(`[AgentProcessManager] lifecycle.turn.completed: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${capabilities.supportsSessionResume}`);
     if (capabilities.supportsSessionResume) {
       const service = this.deps.agentServices.get(opts.harness);
       if (service?.resumeTurn) {
@@ -84082,6 +84187,18 @@ class AgentProcessManager {
     const harness = slot.harness;
     const model = slot.model;
     const workingDir = slot.workingDir;
+    const harnessSessionId = slot.harnessSessionId;
+    if (harness && harnessSessionId && getHarnessCapabilities(harness).supportsSessionResume && shouldRetainHarnessSessionForReconnect(stopReason)) {
+      const service = this.deps.agentServices.get(harness);
+      const harnessMeta = service ? this.readHarnessReconnectMetadata(service, opts.pid) : undefined;
+      this.recordLastHarnessSession(key, {
+        harnessSessionId,
+        harness,
+        agentName: harnessMeta?.agentName ?? "",
+        workingDir: workingDir ?? "",
+        model: model ?? harnessMeta?.model
+      });
+    }
     slot.state = "idle";
     slot.pid = undefined;
     slot.startedAt = undefined;
@@ -84108,13 +84225,10 @@ class AgentProcessManager {
     for (const service of this.deps.agentServices.values()) {
       service.untrack(opts.pid);
     }
-    const isIntentionalStop = stopReason === "user.stop" || stopReason === "platform.team_switch" || stopReason === "daemon.shutdown";
-    const isDaemonRespawn = stopReason === "daemon.respawn";
-    if (isIntentionalStop) {
-      this.deps.crashLoop.clear(opts.chatroomId, opts.role);
-      return;
-    }
-    if (isDaemonRespawn) {
+    if (!shouldAutoRestartAfterProcessExit(stopReason)) {
+      if (stopReason === "user.stop" || stopReason === "platform.team_switch" || stopReason === "daemon.shutdown") {
+        this.deps.crashLoop.clear(opts.chatroomId, opts.role);
+      }
       return;
     }
     if (!harness || !workingDir) {
@@ -84473,7 +84587,12 @@ class AgentProcessManager {
         return { success: false, error: `Unknown agent harness: ${opts.agentHarness}` };
       }
       let spawnResult;
-      if (wantResume) {
+      const resumePath = decideResumePathOnRestart({
+        supportsSessionResume: getHarnessCapabilities(opts.agentHarness).supportsSessionResume,
+        wantResume,
+        hasStoredSnapshot: this.lastHarnessSessions.has(key)
+      });
+      if (resumePath === "daemon_memory") {
         spawnResult = await this.tryDaemonMemoryResume({
           key,
           chatroomId: opts.chatroomId,
@@ -84590,7 +84709,8 @@ class AgentProcessManager {
     try {
       const harness = slot.harness;
       const service = harness ? this.deps.agentServices.get(harness) : undefined;
-      const preserveForResume = opts.reason === "user.stop" && Boolean(slot.harnessSessionId);
+      const supportsResume = harness ? getHarnessCapabilities(harness).supportsSessionResume : false;
+      const preserveForResume = shouldPreserveHarnessTeardown(opts.reason, supportsResume, Boolean(slot.harnessSessionId));
       if (harness && slot.harnessSessionId) {
         if (preserveForResume) {
           const harnessMeta = service ? this.readHarnessReconnectMetadata(service, pid) : undefined;
@@ -84668,6 +84788,7 @@ var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
 var init_agent_process_manager = __esm(() => {
   init_orphan_tracker();
   init_api3();
+  init_agent_lifecycle();
   init_types();
   init_generator();
 });
@@ -85246,6 +85367,62 @@ var init_observed_sync = __esm(() => {
   init_convex_error();
 });
 
+// src/commands/machine/daemon-start/workspace-list-subscription.ts
+function toSyncWorkspaces(workspaces) {
+  return workspaces.map((ws) => ({ workingDir: ws.workingDir }));
+}
+function applyWorkspaceList(ctx, workspaces) {
+  if (!ctx.workspaceListStore)
+    return;
+  ctx.workspaceListStore.workspaces = toSyncWorkspaces(workspaces);
+  ctx.workspaceListStore.updatedAt = Date.now();
+}
+function startWorkspaceListSubscription(ctx, wsClient2) {
+  ctx.workspaceListStore = { workspaces: [], updatedAt: 0 };
+  const queryArgs = {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    recencyWindowMs: WORKSPACE_RECENCY_WINDOW_MS
+  };
+  let stopped = false;
+  let reconcileInFlight = false;
+  const unsubscribe = wsClient2.onUpdate(api.workspaces.listRecentlyObservedWorkspacesForMachine, queryArgs, (workspaces) => {
+    if (stopped)
+      return;
+    applyWorkspaceList(ctx, workspaces ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Workspace-list subscription error: ${getErrorMessage(err)}`);
+  });
+  const reconcileTimer = setInterval(() => {
+    if (stopped || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    ctx.deps.backend.query(api.workspaces.listRecentlyObservedWorkspacesForMachine, queryArgs).then((workspaces) => {
+      if (!stopped)
+        applyWorkspaceList(ctx, workspaces ?? []);
+    }).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Workspace-list reconcile failed: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      reconcileInFlight = false;
+    });
+  }, WORKSPACE_LIST_RECONCILE_MS);
+  console.log(`[${formatTimestamp()}] \uD83D\uDCC2 Workspace-list subscription started`);
+  return {
+    stop: () => {
+      stopped = true;
+      unsubscribe();
+      clearInterval(reconcileTimer);
+      delete ctx.workspaceListStore;
+      console.log(`[${formatTimestamp()}] \uD83D\uDCC2 Workspace-list subscription stopped`);
+    }
+  };
+}
+var init_workspace_list_subscription = __esm(() => {
+  init_reliability();
+  init_api3();
+  init_convex_error();
+});
+
 // src/infrastructure/git/git-writer.ts
 import { exec as exec5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
@@ -85961,7 +86138,6 @@ async function startCommandLoop(ctx) {
     }).then(() => {
       heartbeatCount++;
       console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
-      invalidateWorkspacesForMachineCache(ctx);
       if (!ctx.observedSyncEnabled) {
         pushGitState(ctx).catch((err) => {
           console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
@@ -85981,8 +86157,9 @@ async function startCommandLoop(ctx) {
   let gitSubscriptionHandle = null;
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
+  let workspaceListSubscriptionHandle = null;
   let observedSyncSubscriptionHandle = null;
-  let logObserverPollHandle = null;
+  let logObserverSubscriptionHandle = null;
   let pendingPromptSubscriptionHandle = null;
   let pendingHarnessSessionSubscriptionHandle = null;
   let commandSubscriptionHandle = null;
@@ -86006,10 +86183,12 @@ async function startCommandLoop(ctx) {
       fileContentSubscriptionHandle.stop();
     if (fileTreeSubscriptionHandle)
       fileTreeSubscriptionHandle.stop();
+    if (workspaceListSubscriptionHandle)
+      workspaceListSubscriptionHandle.stop();
     if (observedSyncSubscriptionHandle)
       observedSyncSubscriptionHandle.stop();
-    if (logObserverPollHandle)
-      logObserverPollHandle.stop();
+    if (logObserverSubscriptionHandle)
+      logObserverSubscriptionHandle.stop();
     if (pendingPromptSubscriptionHandle)
       pendingPromptSubscriptionHandle.stop();
     if (pendingHarnessSessionSubscriptionHandle)
@@ -86035,10 +86214,11 @@ async function startCommandLoop(ctx) {
   gitSubscriptionHandle = startGitRequestSubscription(ctx, wsClient2);
   fileContentSubscriptionHandle = startFileContentSubscription(ctx, wsClient2);
   fileTreeSubscriptionHandle = startFileTreeSubscription(ctx, wsClient2);
+  workspaceListSubscriptionHandle = startWorkspaceListSubscription(ctx, wsClient2);
   if (ctx.observedSyncEnabled) {
     observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
   }
-  logObserverPollHandle = startLogObserverPoll(ctx);
+  logObserverSubscriptionHandle = startLogObserverSubscription(ctx, wsClient2);
   if (featureFlags.directHarnessWorkers) {
     const sessionRepository = new ConvexSessionRepository({
       backend: ctx.deps.backend,
@@ -86128,8 +86308,8 @@ var init_command_loop = __esm(() => {
   init_manager();
   init_init2();
   init_log_observer_sync();
-  init_workspace_cache();
   init_observed_sync();
+  init_workspace_list_subscription();
   init_api3();
   init_client2();
   init_local_actions();
@@ -87304,8 +87484,8 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
   if (!sessionId)
     return;
   const client4 = await getConvexClient2();
-  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role, action: actionCommand.name() });
+  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role });
 });
 program2.parse();
 
-//# debugId=D59205F0E7B31DAD64756E2164756E21
+//# debugId=738F13B9B9408F0B64756E2164756E21