chatroom-cli 1.107.0 → 1.107.1

package/dist/index.js

@@ -80716,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
@@ -106082,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",
@@ -118155,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")}:`;
@@ -118194,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;
@@ -118230,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;
@@ -118283,7 +118311,7 @@ async function bootstrapMachineAssignedTaskSnapshots(deps) {
 function isAbortError2(error51) {
   return error51 instanceof Error && error51.name === "AbortError";
 }
-function operationalScopeKey(machineId, chatroomId) {
+function roomScopeKey(machineId, chatroomId) {
   return JSON.stringify([machineId, chatroomId]);
 }
 async function runInboxLoopWithRestart(options, onUpdate, isStopped) {
@@ -118337,10 +118365,6 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
   };
   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 serviceStartedAt = Date.now();
   const abort = new AbortController;
   let stopped = false;
@@ -118361,14 +118385,6 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
   const cooldown = new RecoveryCooldown;
   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 bootstrapSucceeded = yield* exports_Effect.tryPromise(async () => {
     const rows = await fetchMachineAgentOperationalStatus(sessionDeps, session2.machineId);
     agentOperationalReadModel.replace(rows);
@@ -118390,7 +118406,7 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
       }
       inboxStore.save({
         inboxType: "operational",
-        scopeKey: operationalScopeKey(session2.machineId, chatroomId)
+        scopeKey: roomScopeKey(session2.machineId, chatroomId)
       }, { afterSignalKey: update6.throughSignalKey });
       try {
         await ackMachineOperationalSignals(sessionDeps, session2.machineId, chatroomId, update6.throughSignalKey);
@@ -118401,7 +118417,7 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
       inboxUpdatesInFlight -= 1;
     }
   };
-  const ensureOperationalInbox = (chatroomId) => {
+  const ensureRoomInboxes = (chatroomId) => {
     const existing = roomWatchers.get(chatroomId);
     if (existing)
       return existing.startPromise;
@@ -118422,25 +118438,25 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
           console.warn(`[OperationalInbox room=${chatroomId}] operational hydration failed:`, error51);
         }
       }
-      const roomKey = {
+      const operationalRoomKey = {
         inboxType: "operational",
-        scopeKey: operationalScopeKey(session2.machineId, chatroomId)
+        scopeKey: roomScopeKey(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));
+      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) {
-        initialCursor = operationalSignalCursorAt(serviceStartedAt);
+        operationalCursor = 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));
+          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 {
-        initialCursor = operationalSignalCursorAt(serviceStartedAt);
+        operationalCursor = operationalSignalCursorAt(serviceStartedAt);
       }
       runOperationalInboxLoopWithRestart({
         client: wsClient2,
@@ -118448,13 +118464,57 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
         machineId: session2.machineId,
         chatroomId,
         serviceStartedAt,
-        initialAfterSignalKey: initialCursor,
+        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) => ensureOperationalInbox(chatroomId)))).pipe(exports_Effect.catchAll((error51) => {
+  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;
   }));
@@ -118467,49 +118527,33 @@ var NATIVE_DELIVERY_RECONCILE_MS = 1e4, INBOX_RESTART_INITIAL_MS = 1000, INBOX_R
     machineId: session2.machineId,
     taskSnapshotState,
     onDiscoveredChatrooms: async (chatroomIds) => {
-      await Promise.all(chatroomIds.map((chatroomId) => ensureOperationalInbox(chatroomId)));
+      await Promise.all(chatroomIds.map((chatroomId) => ensureRoomInboxes(chatroomId)));
     }
   })).pipe(exports_Effect.catchAll((error51) => {
     console.warn("[TaskInbox] bootstrap failed:", error51);
     return exports_Effect.void;
   }));
-  const inboxHandler = async (update6) => {
-    inboxUpdatesInFlight += 1;
-    try {
-      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 {
-      inboxUpdatesInFlight -= 1;
-    }
-  };
   const reconcileTimer = setInterval(() => {
     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);
   return {
     stop() {
       stopped = true;
@@ -119684,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) {
@@ -119695,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(() => {
@@ -119859,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) {
@@ -119871,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(() => {
@@ -119928,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,
@@ -119936,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([
@@ -135734,4 +135878,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=962BD51641BEFD4F64756E2164756E21
+//# debugId=3C68FDC314358C7A64756E2164756E21