chatroom-cli 1.106.0 → 1.107.1

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`).";
 });
@@ -80698,6 +80716,7 @@ ${getHandoffNotApplicableSectionComment("List tradeoffs")}
 
 ## System Design
 ${getHandoffNotApplicableSectionComment("Include a mermaid diagram when the change has non-trivial structure")}
+<!-- Mermaid formatting: wrap the diagram in a fenced code block that begins with \`\`\`mermaid and ends with \`\`\`. Never write a bare "mermaid" line — it will not render. -->
 
 \`\`\`mermaid
 flowchart TD
@@ -106064,6 +106083,7 @@ var init_model_catalog = __esm(() => {
   init_model_provider();
   init_model_variant();
   CODEX_MODEL_IDS = [
+    "gpt-6-astra",
     "gpt-5.6-terra",
     "gpt-5.6-luna",
     "gpt-5.6-sol",
@@ -116251,11 +116271,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 +116293,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 +116315,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 +116405,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 +116429,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 +116462,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 +116482,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 +117785,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 +117908,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 +117946,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 +117966,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,
@@ -118035,6 +118157,30 @@ var init_task_inbox_delivery = __esm(() => {
   init_enrich_snapshot_with_operational();
 });
 
+// src/daemon/infrastructure/inbox/task-signal-contract.ts
+function asChatroomId2(chatroomId) {
+  return chatroomId;
+}
+function buildSubscribeTaskStatusSignalsSinceArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: asChatroomId2(input.chatroomId),
+    afterKey: input.afterKey,
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  };
+}
+function buildListTasksForMachineSignalRangeArgs(input) {
+  return {
+    sessionId: input.sessionId,
+    machineId: input.machineId,
+    chatroomId: asChatroomId2(input.chatroomId),
+    afterSignalKey: input.afterSignalKey,
+    throughSignalKey: input.throughSignalKey,
+    ...input.limit === undefined ? {} : { limit: input.limit }
+  };
+}
+
 // src/daemon/infrastructure/inbox/task.ts
 function taskSignalCursorAt(timestamp) {
   return `${String(Math.max(0, Math.floor(timestamp))).padStart(16, "0")}:`;
@@ -118074,12 +118220,13 @@ function waitForTaskSignalPage(options, afterSignalKey) {
       settle2(() => reject(error51));
       return;
     }
-    unsubscribe = options.client.onUpdate(api.messageList.subscribeTaskStatusSignalsSince, {
+    unsubscribe = options.client.onUpdate(api.messageList.subscribeTaskStatusSignalsSince, buildSubscribeTaskStatusSignalsSinceArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
+      chatroomId: options.chatroomId,
       afterKey: afterSignalKey,
       limit: options.signalPageLimit ?? DEFAULT_SIGNAL_PAGE_LIMIT2
-    }, (result) => {
+    }), (result) => {
       if (!result || typeof result !== "object")
         return;
       const page = result;
@@ -118110,13 +118257,14 @@ async function fetchSnapshotsForSignalPage(options, page) {
   let afterSignalKey = page.afterSignalKey;
   while (true) {
     throwIfAborted2(options.signal);
-    const result = await options.client.query(api.tasks.listTasksForMachineSignalRange, {
+    const result = await options.client.query(api.tasks.listTasksForMachineSignalRange, buildListTasksForMachineSignalRangeArgs({
       sessionId: options.sessionId,
       machineId: options.machineId,
+      chatroomId: options.chatroomId,
       afterSignalKey,
       throughSignalKey: page.highSignalKey,
       limit: options.taskPageLimit ?? DEFAULT_TASK_PAGE_LIMIT
-    });
+    }));
     snapshots.push(...result.snapshots);
     if (!result.hasMore || !result.nextSignalKey)
       break;
@@ -118152,6 +118300,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 +118311,9 @@ async function bootstrapMachineAssignedTaskSnapshots(deps) {
 function isAbortError2(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
 }
+function roomScopeKey(machineId, chatroomId) {
+  return JSON.stringify([machineId, chatroomId]);
+}
 async function runInboxLoopWithRestart(options, onUpdate, isStopped) {
   let backoffMs = INBOX_RESTART_INITIAL_MS;
   while (!isStopped()) {
@@ -118183,7 +118338,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 +118363,15 @@ 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,51 +118383,141 @@ 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,
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    serviceStartedAt,
-    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: roomScopeKey(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 ensureRoomInboxes = (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 operationalRoomKey = {
+        inboxType: "operational",
+        scopeKey: roomScopeKey(session2.machineId, chatroomId)
+      };
+      const persistedOperationalRoom = inboxStore.get(operationalRoomKey);
+      let operationalCursor;
+      if (persistedOperationalRoom) {
+        operationalCursor = persistedOperationalRoom.state.afterSignalKey;
+        ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, operationalCursor).catch((error51) => console.warn(`[OperationalInbox room=${chatroomId}] startup signal cleanup failed:`, error51));
+      } else if (bootstrapSucceeded) {
+        operationalCursor = operationalSignalCursorAt(serviceStartedAt);
+        try {
+          inboxStore.save(operationalRoomKey, { afterSignalKey: operationalCursor });
+          ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, operationalCursor).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 {
+        operationalCursor = operationalSignalCursorAt(serviceStartedAt);
+      }
+      runOperationalInboxLoopWithRestart({
+        client: wsClient2,
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        chatroomId,
+        serviceStartedAt,
+        initialAfterSignalKey: operationalCursor,
+        signal: controller.signal
+      }, operationalHandler, () => stopped);
+      const taskRoomKey = {
+        inboxType: "task",
+        scopeKey: roomScopeKey(session2.machineId, chatroomId)
+      };
+      const persistedTaskRoom = inboxStore.get(taskRoomKey);
+      let taskCursor;
+      if (persistedTaskRoom) {
+        taskCursor = persistedTaskRoom.state.afterSignalKey;
+      } else if (bootstrapSucceeded) {
+        taskCursor = taskSignalCursorAt(serviceStartedAt);
+        try {
+          inboxStore.save(taskRoomKey, { afterSignalKey: taskCursor });
+        } catch (error51) {
+          console.warn(`[TaskInbox room=${chatroomId}] failed to persist bootstrap baseline:`, error51);
+        }
+      } else {
+        taskCursor = taskSignalCursorAt(serviceStartedAt);
+      }
+      const taskHandlerForRoom = async (update6) => {
+        inboxUpdatesInFlight += 1;
+        try {
+          await handleTaskInboxUpdate(update6, {
+            runtime: runtime4,
+            effectContext: effectContext2,
+            cooldown,
+            agentMgr,
+            sessionDeps,
+            machineId: session2.machineId,
+            taskSnapshotState
+          });
+          inboxStore.save(taskRoomKey, { afterSignalKey: update6.throughSignalKey });
+        } finally {
+          inboxUpdatesInFlight -= 1;
+        }
+      };
+      runInboxLoopWithRestart({
+        client: wsClient2,
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        chatroomId,
+        serviceStartedAt,
+        initialAfterSignalKey: taskCursor,
+        signal: controller.signal
+      }, taskHandlerForRoom, () => stopped);
+    })();
+    return entry.startPromise;
+  };
+  yield* exports_Effect.tryPromise(() => Promise.all([...knownRoomIds].map((chatroomId) => ensureRoomInboxes(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,53 +118525,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) => ensureRoomInboxes(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;
-    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);
-      }
-    } finally {
-      inboxUpdateInFlight = false;
-    }
-  };
   const reconcileTimer = setInterval(() => {
-    if (stopped || inboxUpdateInFlight || reconcileInFlight)
+    if (stopped || inboxUpdatesInFlight > 0 || reconcileInFlight)
       return;
     reconcileInFlight = true;
+    (async () => {
+      try {
+        const current = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
+        agentOperationalReadModel.replace(current);
+        for (const row of current)
+          knownRoomIds.add(row.chatroomId);
+        await Promise.all([...new Set(current.map((row) => row.chatroomId))].map((chatroomId) => ensureRoomInboxes(chatroomId)));
+      } catch (error51) {
+        console.warn("[TaskInbox] room membership refresh failed:", error51);
+      }
+    })();
     processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr, sessionDeps, session2.machineId, "periodic-reconcile", { snapshots: enrichSnapshotsWithOperational(taskSnapshotState.listAll()) }).catch((error51) => {
       console.warn("[TaskInbox] local delivery reconciliation failed:", error51);
     }).finally(() => {
       reconcileInFlight = false;
     });
   }, 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();
@@ -119502,7 +119728,10 @@ var init_command_run = __esm(() => {
 // src/daemon/infrastructure/convex/subscribers/enhancer-job.ts
 function startEnhancerJobSubscriber2(deps, onEvent) {
   const seen = new Set;
-  const unsub = deps.wsClient.onUpdate(api.daemon.enhancer.index.pendingForMachine, { sessionId: deps.sessionId, machineId: deps.machineId }, (jobs) => {
+  const watchers = new Map;
+  let stopped = false;
+  let refreshInFlight = false;
+  const onPendingJobs = (jobs) => {
     if (!jobs?.length)
       return;
     for (const job of jobs) {
@@ -119513,13 +119742,57 @@ function startEnhancerJobSubscriber2(deps, onEvent) {
       seen.add(job.jobId);
       onEvent({ type: "enhancer.job-assigned", jobId: job.jobId });
     }
-  }, (err) => {
+  };
+  const onError3 = (err) => {
     console.warn(`[daemon] enhancer-job subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  });
+  };
+  const watchChatroom = (chatroomId) => {
+    if (watchers.has(chatroomId) || stopped)
+      return;
+    const unsub = deps.wsClient.onUpdate(api.daemon.enhancer.index.pendingForChatroom, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      chatroomId
+    }, onPendingJobs, onError3);
+    watchers.set(chatroomId, unsub);
+  };
+  const refreshChatrooms = async () => {
+    if (refreshInFlight)
+      return;
+    refreshInFlight = true;
+    try {
+      const workspaces = await deps.wsClient.query(api.workspaces.listWorkspacesForMachine, {
+        sessionId: deps.sessionId,
+        machineId: deps.machineId
+      });
+      if (stopped)
+        return;
+      const roomIds = [
+        ...new Set((workspaces ?? []).map((ws) => ws.chatroomId))
+      ];
+      for (const [roomId, unsub] of watchers) {
+        if (!roomIds.includes(roomId)) {
+          unsub();
+          watchers.delete(roomId);
+        }
+      }
+      for (const roomId of roomIds)
+        watchChatroom(roomId);
+    } catch (error51) {
+      console.warn(`[daemon] enhancer-job room refresh failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    } finally {
+      refreshInFlight = false;
+    }
+  };
+  refreshChatrooms();
   return {
     async stop() {
-      unsub();
-    }
+      stopped = true;
+      for (const unsub of watchers.values())
+        unsub();
+      watchers.clear();
+    },
+    refreshChatrooms
   };
 }
 var init_enhancer_job = __esm(() => {
@@ -119677,7 +119950,11 @@ function requestId2(req) {
 }
 function startGitRequestSubscriber(deps, onEvent) {
   const seen = new Set;
-  const unsub = deps.wsClient.onUpdate(api.workspaces.getPendingRequests, { sessionId: deps.sessionId, machineId: deps.machineId }, (requests) => {
+  const watchers = new Map;
+  let stopped = false;
+  let refreshInFlight = false;
+  let queued = false;
+  const onPendingRequests = (requests) => {
     if (!requests?.length)
       return;
     for (const req of requests) {
@@ -119689,13 +119966,58 @@ function startGitRequestSubscriber(deps, onEvent) {
       seen.add(id3);
       onEvent({ type: "git.request", requestId: id3 });
     }
-  }, (err) => {
+  };
+  const onError3 = (err) => {
     console.warn(`[daemon] git-request subscriber error: ${err instanceof Error ? err.message : String(err)}`);
-  });
+  };
+  const watchWorkspace = (workingDir) => {
+    if (watchers.has(workingDir) || stopped)
+      return;
+    const unsub = deps.wsClient.onUpdate(api.workspaces.getPendingRequestsForWorkspace, { sessionId: deps.sessionId, machineId: deps.machineId, workingDir }, onPendingRequests, onError3);
+    watchers.set(workingDir, unsub);
+  };
+  const refreshWorkspaces = async () => {
+    if (refreshInFlight) {
+      queued = true;
+      return;
+    }
+    refreshInFlight = true;
+    try {
+      do {
+        queued = false;
+        const workspaces = await deps.wsClient.query(api.workspaces.listWorkspacesForMachine, {
+          sessionId: deps.sessionId,
+          machineId: deps.machineId
+        });
+        if (stopped)
+          return;
+        const workingDirs = [
+          ...new Set((workspaces ?? []).map((ws) => ws.workingDir))
+        ];
+        for (const [workingDir, unsub] of watchers) {
+          if (!workingDirs.includes(workingDir)) {
+            unsub();
+            watchers.delete(workingDir);
+          }
+        }
+        for (const workingDir of workingDirs)
+          watchWorkspace(workingDir);
+      } while (queued && !stopped);
+    } catch (error51) {
+      console.warn(`[daemon] git-request workspace refresh failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    } finally {
+      refreshInFlight = false;
+    }
+  };
+  refreshWorkspaces();
   return {
     async stop() {
-      unsub();
-    }
+      stopped = true;
+      for (const unsub of watchers.values())
+        unsub();
+      watchers.clear();
+    },
+    refreshWorkspaces
   };
 }
 var init_git_request = __esm(() => {
@@ -119746,7 +120068,13 @@ function startAllSubscribers(deps) {
   const onEvent = (event) => {
     routeInboundEvent(deps.router, event);
   };
+  const enhancerJob = startEnhancerJobSubscriber2(deps, onEvent);
+  const gitRequest = startGitRequestSubscriber(deps, onEvent);
   const machineCommands = startMachineCommandInboxSubscriber(deps, async (claimed) => {
+    if (claimed.type === "daemon.workspaceListChanged") {
+      enhancerJob.refreshChatrooms();
+      gitRequest.refreshWorkspaces();
+    }
     await dispatchCommandInboundEvent({
       type: "command.received",
       commandId: claimed.commandId,
@@ -119754,14 +120082,12 @@ function startAllSubscribers(deps) {
     });
   });
   const commandRun = startCommandRunSubscriber(deps, onEvent);
-  const gitRequest = startGitRequestSubscriber(deps, onEvent);
   const fileTree = startFileTreeRequestSubscriber(deps, onEvent);
   const fileTreeRelease = startFileTreeReleaseRequestSubscriber(deps, onEvent);
   const fileContent = startFileContentRequestSubscriber(deps, onEvent);
   const fileWrite = startFileWriteRequestSubscriber(deps, onEvent);
   const agenticQuerySession = startAgenticQuerySessionSubscriber(deps, onEvent);
   const agenticQueryPrompt = startAgenticQueryPromptSubscriber(deps, onEvent);
-  const enhancerJob = startEnhancerJobSubscriber2(deps, onEvent);
   return {
     async stopAll() {
       await Promise.all([
@@ -135552,4 +135878,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D6F1DCA6040634C164756E2164756E21
+//# debugId=3C68FDC314358C7A64756E2164756E21