chatroom-cli 1.106.0 → 1.107.0

package/dist/index.js

@@ -78981,6 +78981,9 @@ var init_machine_service = __esm(() => {
   RegisterAgentMachineService = class RegisterAgentMachineService extends exports_Context.Tag("RegisterAgentMachineService")() {
   };
 });
+// ../../services/backend/convex/workspaceFileTree/access.ts
+var FILE_TREE_SYNC_DISABLED_CODE = "FILE_TREE_SYNC_DISABLED";
+var init_access = () => {};
 
 // src/utils/convex-error.ts
 function formatConvexErrorObject(data) {
@@ -79013,8 +79016,23 @@ function getErrorMessage(error) {
     return formatServerError(error);
   return String(error);
 }
+function getConvexErrorCode(error) {
+  if (!(error instanceof ConvexError))
+    return;
+  const data = error.data;
+  if (data !== null && typeof data === "object" && "code" in data) {
+    const code2 = data.code;
+    if (typeof code2 === "string")
+      return code2;
+  }
+  return;
+}
+function isFileTreeSyncDisabledError(error) {
+  return getConvexErrorCode(error) === FILE_TREE_SYNC_DISABLED_CODE;
+}
 var SERVER_ERROR_HINT;
 var init_convex_error = __esm(() => {
+  init_access();
   init_values();
   SERVER_ERROR_HINT = "This is a generic server error — likely a backend arg-validator rejection or a CLI/backend version mismatch." + " Verify the CLI and backend are on the same commit (run `pnpm install` and check `git log -1 origin/master`).";
 });
@@ -116251,11 +116269,20 @@ async function publishCheckpointUntilPruned(session2, normalizedWorkingDir, snap
   assertCheckpointAccepted(result);
   return checkpointRevision;
 }
-function createWorkspaceFileTreeCheckpointSend(session2, normalizedWorkingDir) {
+function createWorkspaceFileTreeCheckpointSend(session2, normalizedWorkingDir, options) {
   return async (state) => {
-    const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, state.tree, computeFileTreeDataHash(state.tree), randomUUID11());
-    const revision = await publishCheckpointUntilPruned(session2, normalizedWorkingDir, snapshot, state.revision);
-    return { revision };
+    try {
+      const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, state.tree, computeFileTreeDataHash(state.tree), randomUUID11());
+      const revision = await publishCheckpointUntilPruned(session2, normalizedWorkingDir, snapshot, state.revision);
+      return { revision };
+    } catch (error51) {
+      if (!isFileTreeSyncDisabledError(error51))
+        throw error51;
+      (async () => options?.onSyncDisabled?.())().catch(() => {
+        return;
+      });
+      return { revision: state.revision };
+    }
   };
 }
 var init_workspace_file_tree_checkpoint_send = __esm(() => {
@@ -116264,6 +116291,7 @@ var init_workspace_file_tree_checkpoint_send = __esm(() => {
   init_file_tree_data_hash();
   init_blob_snapshot_publish();
   init_sharded_snapshot_publish();
+  init_convex_error();
 });
 
 // src/daemon/infrastructure/outbox/workspace-file-tree-delta-send.ts
@@ -116285,52 +116313,81 @@ function toDeltaOperations(delta) {
     }))
   ];
 }
-function createWorkspaceFileTreeDeltaSend(session2, normalizedWorkingDir) {
+function createWorkspaceFileTreeDeltaSend(session2, normalizedWorkingDir, options) {
   return async (unit) => {
-    const result = await session2.backend.mutation(api.workspaceFiles.applyFileTreeDeltaBatch, {
-      sessionId: session2.sessionId,
-      machineId: session2.machineId,
-      workingDir: normalizedWorkingDir,
-      operationId: unit.delta.operationId,
-      baseRevision: unit.baseRevision,
-      operations: toDeltaOperations(unit.delta)
-    });
-    if (result.status === "resync-required") {
-      return { status: "conflict", revision: result.expectedRevision };
+    try {
+      const result = await session2.backend.mutation(api.workspaceFiles.applyFileTreeDeltaBatch, {
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        workingDir: normalizedWorkingDir,
+        operationId: unit.delta.operationId,
+        baseRevision: unit.baseRevision,
+        operations: toDeltaOperations(unit.delta)
+      });
+      if (result.status === "resync-required") {
+        return { status: "conflict", revision: result.expectedRevision };
+      }
+      return result;
+    } catch (error51) {
+      if (!isFileTreeSyncDisabledError(error51))
+        throw error51;
+      (async () => options?.onSyncDisabled?.())().catch(() => {
+        return;
+      });
+      return { status: "applied", revision: unit.baseRevision };
     }
-    return result;
   };
 }
 var init_workspace_file_tree_delta_send = __esm(() => {
   init_api3();
+  init_convex_error();
 });
 
 // src/daemon/entry/files/file-tree-subscription.ts
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage(err)}`);
 }
-async function runOneShotFileTreeSync(session2, workingDir) {
+async function runOneShotFileTreeSync(session2, workingDir, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
-  const tree = await scanFileTree(normalized);
-  const send = createWorkspaceFileTreeCheckpointSend(session2, normalized);
-  await send({ tree, revision: 0 });
-  await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir: normalized
-  });
+  let syncDisabled = false;
+  try {
+    const tree = await scanFileTree(normalized);
+    const send = createWorkspaceFileTreeCheckpointSend(session2, normalized, {
+      onSyncDisabled: () => {
+        syncDisabled = true;
+      }
+    });
+    await send({ tree, revision: 0 });
+    if (syncDisabled) {
+      await stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+      return;
+    }
+    await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir: normalized
+    });
+  } catch (error51) {
+    if (!isFileTreeSyncDisabledError(error51))
+      throw error51;
+    await stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+  }
 }
 async function stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized) {
   const coordinatorPromise = coordinators.get(normalized);
-  if (!coordinatorPromise)
-    return;
-  coordinators.delete(normalized);
-  await coordinatorPromise.then((coordinator2) => coordinator2.stop()).catch(() => {
-    return;
-  });
+  if (coordinatorPromise) {
+    coordinators.delete(normalized);
+    await coordinatorPromise.then((coordinator2) => coordinator2.stop()).catch(() => {
+      return;
+    });
+  }
   await checkpointOutboxRegistry?.stop(normalized);
   await deltaOutboxRegistry?.stop(normalized);
 }
+async function stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized) {
+  await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+  console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree sync disabled: ${normalized}`);
+}
 async function drainPendingFileTreeReleaseRequests(session2, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry) {
   while (true) {
     const releases = await session2.backend.query(api.workspaceFiles.getPendingFileTreeReleaseRequests, {
@@ -116346,13 +116403,12 @@ async function drainPendingFileTreeReleaseRequests(session2, coordinators, check
     let successCount = 0;
     for (const normalized of releasesByDir) {
       try {
-        await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+        await stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
         await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeReleaseRequest, {
           sessionId: session2.sessionId,
           machineId: session2.machineId,
           workingDir: normalized
         });
-        console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree coordinator stopped: ${normalized}`);
         successCount++;
       } catch (err) {
         logSubscriptionWarn(`File tree release failed for ${normalized}`, err);
@@ -116371,7 +116427,7 @@ async function processOnePendingFileTreeRequest(session2, coordinators, ensureCo
   });
   if (!lease?.leaseActive) {
     await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
-    await runOneShotFileTreeSync(session2, normalized);
+    await runOneShotFileTreeSync(session2, normalized, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry);
     console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree ready: ${normalized} (${Date.now() - start3}ms, one-shot)`);
     return;
   }
@@ -116404,6 +116460,10 @@ async function processPendingFileTreeRequests(session2, coordinators, ensureCoor
       try {
         await processOnePendingFileTreeRequest(session2, coordinators, ensureCoordinator, normalized, force, checkpointOutboxRegistry, deltaOutboxRegistry);
       } catch (err) {
+        if (isFileTreeSyncDisabledError(err)) {
+          await stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+          return;
+        }
         logSubscriptionWarn(`File tree failed for ${normalized}`, err);
       }
     });
@@ -116420,16 +116480,40 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const coordinators = new Map;
   const checkpointOutboxRegistry = createWorkspaceFileTreeCheckpointOutboxRegistry(session2.machineId, (normalized) => {
-    const send = createWorkspaceFileTreeCheckpointSend(session2, normalized);
+    const onSyncDisabled = () => stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+    const send = createWorkspaceFileTreeCheckpointSend(session2, normalized, {
+      onSyncDisabled
+    });
     return async (state) => {
       const result = await send(state);
       console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree checkpoint: ${normalized} (${state.tree.entries.length} entries, revision ${result.revision})`);
       return result;
     };
   }, {
-    onError: (normalized, error51) => logSubscriptionWarn(`File tree checkpoint outbox failed for ${normalized}`, error51)
+    onError: (normalized, error51) => {
+      if (isFileTreeSyncDisabledError(error51)) {
+        stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized).catch(() => {
+          return;
+        });
+        return;
+      }
+      logSubscriptionWarn(`File tree checkpoint outbox failed for ${normalized}`, error51);
+    }
+  });
+  const deltaOutboxRegistry = createWorkspaceFileTreeDeltaOutboxRegistry(session2.machineId, (normalized) => {
+    const onSyncDisabled = () => stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized);
+    return createWorkspaceFileTreeDeltaSend(session2, normalized, { onSyncDisabled });
+  }, {
+    onError: (normalized, error51) => {
+      if (isFileTreeSyncDisabledError(error51)) {
+        stopFileTreeSyncForDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized).catch(() => {
+          return;
+        });
+        return;
+      }
+      logSubscriptionWarn(`File tree delta outbox failed for ${normalized}`, error51);
+    }
   });
-  const deltaOutboxRegistry = createWorkspaceFileTreeDeltaOutboxRegistry(session2.machineId, (normalized) => createWorkspaceFileTreeDeltaSend(session2, normalized));
   const ensureCoordinator = (workingDir, forceReconcile) => {
     const normalized = normalizeWorkingDirForLookup(workingDir);
     let coordinatorPromise = coordinators.get(normalized);
@@ -117699,14 +117783,47 @@ var init_task_delivery_processor = __esm(() => {
   init_task_delivery_logic();
 });
 
+// src/daemon/infrastructure/agent-operational/operational-signal-contract.ts
+function asChatroomId(chatroomId) {
+  return chatroomId;
+}
+function buildSubscribeMachineOperationalSignalsSinceArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: asChatroomId(input.chatroomId),
+    afterKey: input.afterKey,
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  };
+}
+function buildListOperationalStatusForMachineSignalRangeArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: asChatroomId(input.chatroomId),
+    afterSignalKey: input.afterSignalKey,
+    throughSignalKey: input.throughSignalKey,
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  };
+}
+function buildAckMachineOperationalSignalsArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: asChatroomId(input.chatroomId),
+    throughSignalKey: input.throughSignalKey
+  };
+}
+
 // src/daemon/infrastructure/agent-operational/ack-machine-operational-signals.ts
-async function ackMachineOperationalSignals(sessionDeps, machineId, throughSignalKey) {
+async function ackMachineOperationalSignals(sessionDeps, machineId, chatroomId, throughSignalKey) {
   while (true) {
-    const result = await sessionDeps.backend.mutation(api.machines.ackMachineOperationalSignals, {
+    const result = await sessionDeps.backend.mutation(api.machines.ackMachineOperationalSignals, buildAckMachineOperationalSignalsArgs({
       sessionId: sessionDeps.sessionId,
       machineId,
+      chatroomId,
       throughSignalKey
-    });
+    }));
     if (!result.hasMore)
       return;
     if (result.deletedCount === 0) {
@@ -117789,12 +117906,13 @@ function waitForOperationalSignalPage(options, afterSignalKey) {
       settle2(() => reject(error51));
       return;
     }
-    unsubscribe = options.client.onUpdate(api.machines.subscribeMachineOperationalSignalsSince, {
+    unsubscribe = options.client.onUpdate(api.machines.subscribeMachineOperationalSignalsSince, buildSubscribeMachineOperationalSignalsSinceArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
+      chatroomId: options.chatroomId,
       afterKey: afterSignalKey,
       limit: options.signalPageLimit ?? DEFAULT_SIGNAL_PAGE_LIMIT
-    }, (result) => {
+    }), (result) => {
       if (!result || typeof result !== "object")
         return;
       const page = result;
@@ -117826,13 +117944,14 @@ async function fetchRowsForSignalPage(options, page) {
   let afterSignalKey = page.afterSignalKey;
   while (true) {
     throwIfAborted(options.signal);
-    const result = await options.client.query(api.machines.listOperationalStatusForMachineSignalRange, {
+    const result = await options.client.query(api.machines.listOperationalStatusForMachineSignalRange, buildListOperationalStatusForMachineSignalRangeArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
+      chatroomId: options.chatroomId,
       afterSignalKey,
       throughSignalKey: page.highSignalKey,
       limit: options.operationalPageLimit ?? DEFAULT_OPERATIONAL_PAGE_LIMIT
-    });
+    }));
     rows.push(...result.rows);
     removed.push(...result.removed);
     if (!result.hasMore || !result.nextSignalKey)
@@ -117845,6 +117964,7 @@ async function runOperationalInbox(options, onUpdate) {
   for await (const page of createOperationalSignalIterator(options)) {
     const hydrated = await fetchRowsForSignalPage(options, page);
     await onUpdate({
+      chatroomId: options.chatroomId,
       signals: page.items,
       rows: hydrated.rows,
       removed: hydrated.removed,
@@ -118152,6 +118272,10 @@ async function bootstrapMachineAssignedTaskSnapshots(deps) {
   });
   const tasks = await fetchMachineAssignedTaskSnapshots(deps.sessionDeps, deps.machineId);
   deps.taskSnapshotState?.replace(tasks);
+  const chatroomIds = [...new Set(tasks.map((task) => task.chatroomId))];
+  if (chatroomIds.length > 0) {
+    await deps.onDiscoveredChatrooms?.(chatroomIds);
+  }
   if (!tasks.length)
     return;
   await processTasksUpdate(deps.runtime, deps.effectContext, deps.cooldown, deps.agentMgr, deps.sessionDeps, deps.machineId, "bootstrap", { snapshots: enrichSnapshotsWithOperational(tasks) });
@@ -118159,6 +118283,9 @@ async function bootstrapMachineAssignedTaskSnapshots(deps) {
 function isAbortError2(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
 }
+function operationalScopeKey(machineId, chatroomId) {
+  return JSON.stringify([machineId, chatroomId]);
+}
 async function runInboxLoopWithRestart(options, onUpdate, isStopped) {
   let backoffMs = INBOX_RESTART_INITIAL_MS;
   while (!isStopped()) {
@@ -118183,7 +118310,7 @@ async function runOperationalInboxLoopWithRestart(options, onUpdate, isStopped)
     } catch (error51) {
       if (isStopped() || isAbortError2(error51))
         return;
-      console.warn(`[OperationalInbox] loop error, restarting in ${backoffMs}ms:`, error51);
+      console.warn(`[OperationalInbox room=${options.chatroomId}] loop error, restarting in ${backoffMs}ms:`, error51);
       await new Promise((resolve8) => setTimeout(resolve8, backoffMs));
       backoffMs = Math.min(backoffMs * 2, INBOX_RESTART_MAX_MS);
     }
@@ -118208,23 +118335,19 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
       query: (fn2, args2) => session2.backend.query(fn2, args2)
     }
   };
-  console.log(`[${formatTimestamp()}] \uD83D\uDCEC Starting task-inbox (machine-scoped signals)`);
+  console.log(`[${formatTimestamp()}] \uD83D\uDCEC Starting task-inbox (chatroom-scoped operational signals)`);
   const inboxStore = createInboxStateStore(resolveInboxDbPath(session2.machineId));
   const persisted = inboxStore.get({
     inboxType: "task",
     scopeKey: session2.machineId
   });
-  const persistedOperational = inboxStore.get({
-    inboxType: "operational",
-    scopeKey: session2.machineId
-  });
   const serviceStartedAt = Date.now();
-  const persistedOperationalKey = persistedOperational?.state.afterSignalKey;
-  const initialOperationalKey = persistedOperationalKey ?? operationalSignalCursorAt(serviceStartedAt);
   const abort = new AbortController;
   let stopped = false;
   const taskSnapshotState = new MachineTaskSnapshotState;
   const agentOperationalReadModel = new AgentOperationalReadModel;
+  const knownRoomIds = new Set;
+  const roomWatchers = new Map;
   registerNativeDeliverySession({
     runtime: runtime4,
     effectContext: effectContext2,
@@ -118236,7 +118359,7 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     lifecycleOutbox
   });
   const cooldown = new RecoveryCooldown;
-  let inboxUpdateInFlight = false;
+  let inboxUpdatesInFlight = 0;
   let reconcileInFlight = false;
   const inboxOptions = {
     client: wsClient2,
@@ -118246,41 +118369,95 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     initialAfterSignalKey: persisted?.state.afterSignalKey,
     signal: abort.signal
   };
-  const inboxHandler = async (update6) => {
-    inboxUpdateInFlight = true;
-    try {
-      await handleTaskInboxUpdate(update6, {
-        runtime: runtime4,
-        effectContext: effectContext2,
-        cooldown,
-        agentMgr,
-        sessionDeps,
-        machineId: session2.machineId,
-        taskSnapshotState
-      });
-      inboxStore.save({ inboxType: "task", scopeKey: session2.machineId }, { afterSignalKey: update6.throughSignalKey });
-    } finally {
-      inboxUpdateInFlight = false;
-    }
-  };
   const bootstrapSucceeded = yield* exports_Effect.tryPromise(async () => {
     const rows = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
     agentOperationalReadModel.replace(rows);
+    for (const row of rows)
+      knownRoomIds.add(row.chatroomId);
     return true;
   }).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[OperationalInbox] bootstrap failed:", error51);
     return exports_Effect.succeed(false);
   }));
-  if (persistedOperationalKey) {
-    ackMachineOperationalSignals(sessionDeps, session2.machineId, persistedOperationalKey).catch((error51) => console.warn("[OperationalInbox] startup signal cleanup failed:", error51));
-  } else if (bootstrapSucceeded) {
+  const operationalHandler = async (update6) => {
+    const chatroomId = update6.chatroomId;
+    inboxUpdatesInFlight += 1;
     try {
-      inboxStore.save({ inboxType: "operational", scopeKey: session2.machineId }, { afterSignalKey: initialOperationalKey });
-      ackMachineOperationalSignals(sessionDeps, session2.machineId, initialOperationalKey).catch((error51) => console.warn("[OperationalInbox] startup signal cleanup failed:", error51));
-    } catch (error51) {
-      console.warn("[OperationalInbox] failed to persist bootstrap baseline:", error51);
+      const changed = agentOperationalReadModel.applySignalPage(update6.rows, update6.removed);
+      const snapshots = changed.flatMap(({ chatroomId: roomId, role }) => taskSnapshotState.listForRole(roomId, role));
+      if (snapshots.length > 0) {
+        await processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "operational-status", { snapshots: enrichSnapshotsWithOperational(snapshots) });
+      }
+      inboxStore.save({
+        inboxType: "operational",
+        scopeKey: operationalScopeKey(session2.machineId, chatroomId)
+      }, { afterSignalKey: update6.throughSignalKey });
+      try {
+        await ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, update6.throughSignalKey);
+      } catch (error51) {
+        console.warn(`[OperationalInbox room=${chatroomId}] signal cleanup failed:`, error51);
+      }
+    } finally {
+      inboxUpdatesInFlight -= 1;
     }
-  }
+  };
+  const ensureOperationalInbox = (chatroomId) => {
+    const existing = roomWatchers.get(chatroomId);
+    if (existing)
+      return existing.startPromise;
+    const controller = new AbortController;
+    const entry = {
+      controller,
+      startPromise: Promise.resolve()
+    };
+    roomWatchers.set(chatroomId, entry);
+    entry.startPromise = (async () => {
+      if (!knownRoomIds.has(chatroomId)) {
+        try {
+          const current = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
+          agentOperationalReadModel.replace(current);
+          for (const row of current)
+            knownRoomIds.add(row.chatroomId);
+        } catch (error51) {
+          console.warn(`[OperationalInbox room=${chatroomId}] operational hydration failed:`, error51);
+        }
+      }
+      const roomKey = {
+        inboxType: "operational",
+        scopeKey: operationalScopeKey(session2.machineId, chatroomId)
+      };
+      const persistedRoom = inboxStore.get(roomKey);
+      let initialCursor;
+      if (persistedRoom) {
+        initialCursor = persistedRoom.state.afterSignalKey;
+        ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, initialCursor).catch((error51) => console.warn(`[OperationalInbox room=${chatroomId}] startup signal cleanup failed:`, error51));
+      } else if (bootstrapSucceeded) {
+        initialCursor = operationalSignalCursorAt(serviceStartedAt);
+        try {
+          inboxStore.save(roomKey, { afterSignalKey: initialCursor });
+          ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, initialCursor).catch((error51) => console.warn(`[OperationalInbox room=${chatroomId}] startup signal cleanup failed:`, error51));
+        } catch (error51) {
+          console.warn(`[OperationalInbox room=${chatroomId}] failed to persist bootstrap baseline:`, error51);
+        }
+      } else {
+        initialCursor = operationalSignalCursorAt(serviceStartedAt);
+      }
+      runOperationalInboxLoopWithRestart({
+        client: wsClient2,
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        chatroomId,
+        serviceStartedAt,
+        initialAfterSignalKey: initialCursor,
+        signal: controller.signal
+      }, operationalHandler, () => stopped);
+    })();
+    return entry.startPromise;
+  };
+  yield* exports_Effect.tryPromise(() => Promise.all([...knownRoomIds].map((chatroomId) => ensureOperationalInbox(chatroomId)))).pipe(exports_Effect.catchAll((error51) => {
+    console.warn("[OperationalInbox] initial watcher start failed:", error51);
+    return exports_Effect.void;
+  }));
   yield* exports_Effect.tryPromise(() => bootstrapMachineAssignedTaskSnapshots({
     sessionDeps,
     runtime: runtime4,
@@ -118288,39 +118465,42 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     cooldown,
     agentMgr,
     machineId: session2.machineId,
-    taskSnapshotState
+    taskSnapshotState,
+    onDiscoveredChatrooms: async (chatroomIds) => {
+      await Promise.all(chatroomIds.map((chatroomId) => ensureOperationalInbox(chatroomId)));
+    }
   })).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[TaskInbox] bootstrap failed:", error51);
     return exports_Effect.void;
   }));
-  const operationalInboxOptions = {
-    client: wsClient2,
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    serviceStartedAt,
-    initialAfterSignalKey: initialOperationalKey,
-    signal: abort.signal
-  };
-  const operationalInboxHandler = async (update6) => {
-    inboxUpdateInFlight = true;
+  const inboxHandler = async (update6) => {
+    inboxUpdatesInFlight += 1;
     try {
-      const changed = agentOperationalReadModel.applySignalPage(update6.rows, update6.removed);
-      const snapshots = changed.flatMap(({ chatroomId, role }) => taskSnapshotState.listForRole(chatroomId, role));
-      if (snapshots.length > 0) {
-        await processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "operational-status", { snapshots: enrichSnapshotsWithOperational(snapshots) });
-      }
-      inboxStore.save({ inboxType: "operational", scopeKey: session2.machineId }, { afterSignalKey: update6.throughSignalKey });
-      try {
-        await ackMachineOperationalSignals(sessionDeps, session2.machineId, update6.throughSignalKey);
-      } catch (error51) {
-        console.warn("[OperationalInbox] signal cleanup failed:", error51);
+      const chatroomIds = [
+        ...new Set([
+          ...update6.snapshots.map((snapshot) => snapshot.chatroomId),
+          ...update6.signals.map((signal) => signal.chatroomId)
+        ])
+      ];
+      if (chatroomIds.length > 0) {
+        await Promise.all(chatroomIds.map((chatroomId) => ensureOperationalInbox(chatroomId)));
       }
+      await handleTaskInboxUpdate(update6, {
+        runtime: runtime4,
+        effectContext: effectContext2,
+        cooldown,
+        agentMgr,
+        sessionDeps,
+        machineId: session2.machineId,
+        taskSnapshotState
+      });
+      inboxStore.save({ inboxType: "task", scopeKey: session2.machineId }, { afterSignalKey: update6.throughSignalKey });
     } finally {
-      inboxUpdateInFlight = false;
+      inboxUpdatesInFlight -= 1;
     }
   };
   const reconcileTimer = setInterval(() => {
-    if (stopped || inboxUpdateInFlight || reconcileInFlight)
+    if (stopped || inboxUpdatesInFlight > 0 || reconcileInFlight)
       return;
     reconcileInFlight = true;
     processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: enrichSnapshotsWithOperational(taskSnapshotState.listAll()) }).catch((error51) => {
@@ -118330,11 +118510,13 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     });
   }, NATIVE_DELIVERY_RECONCILE_MS);
   runInboxLoopWithRestart(inboxOptions, inboxHandler, () => stopped);
-  runOperationalInboxLoopWithRestart(operationalInboxOptions, operationalInboxHandler, () => stopped);
   return {
     stop() {
       stopped = true;
       abort.abort();
+      for (const watcher of roomWatchers.values()) {
+        watcher.controller.abort();
+      }
       clearInterval(reconcileTimer);
       unregisterNativeDeliverySession();
       inboxStore.close();
@@ -135552,4 +135734,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D6F1DCA6040634C164756E2164756E21
+//# debugId=962BD51641BEFD4F64756E2164756E21