@saadnvd1/agent-os 0.3.512 → 0.3.514

package/lib/chat/activity.ts

@@ -3,7 +3,7 @@ import { formatTokens } from "./context";
 import { formatElapsed } from "./elapsed";
 import { registry, type Live } from "./registry";
 import { stallThresholdMs } from "./stall";
-import { listItems } from "./store";
+import { lastItems, runningItems } from "./store";
 import type { WorkerEvent } from "./worker/protocol";
 
 const lastWhat = (i: ChatItem): string =>
@@ -55,23 +55,17 @@ export function track(live: Live, e: WorkerEvent): void {
 
 // After a reattach, what's still running comes from the saved items.
 export function restoreActivity(sessionId: string, state: ChatState) {
-  const items = listItems(sessionId);
   const activity: Live["activity"] = { tools: new Map(), tasks: new Set() };
-  if (state !== "idle")
-    activity.turnStartedAt = items.findLast(
-      (i) => i.kind === "user"
-    )?.createdAt;
   if (state !== "idle") {
-    const last = items.at(-1);
+    activity.turnStartedAt = lastItems(sessionId, 1, "user")[0]?.createdAt;
+    const last = lastItems(sessionId, 1)[0];
     activity.lastAt = last?.createdAt ?? activity.turnStartedAt;
     activity.lastWhat = last ? lastWhat(last) : undefined;
-  }
-  for (const i of items) {
-    if (i.kind === "tool" && i.status === "running" && state !== "idle")
+    for (const i of runningItems(sessionId, "tool"))
       activity.tools.set(i.id, { label: i.title, since: i.createdAt });
-    if (i.kind === "task" && i.status === "running" && !i.ambient)
-      activity.tasks.add(i.taskId);
   }
+  for (const i of runningItems(sessionId, "task"))
+    if (!i.ambient) activity.tasks.add(i.taskId);
   return activity;
 }
 

package/lib/chat/events.ts

@@ -311,7 +311,7 @@ export interface ToolBody {
 export type ChatServerMessage =
   | {
       type: "snapshot";
-      // Every item, or the latest page for a client that asked (?paged=1).
+      // The latest page; older ones come with `history`.
       items: ChatItem[];
       // Where older items start, and whether there are any.
       cursor: number | null;

package/lib/chat/registry.ts

@@ -9,6 +9,11 @@ import type {
   ChatState,
   Compacting,
 } from "./events";
+import { markStatusDirty } from "../status/dirty";
+import { FLUSH_MS } from "./store";
+
+// Long enough for the worker's buffered write of an item to land.
+const EMIT_SETTLE_MS = 2 * FLUSH_MS;
 
 // A conversation whose worker this server is connected to.
 export interface Live {
@@ -82,6 +87,9 @@ registry.caps ??= new Map();
 registry.connecting ??= new Map();
 
 export function emit(sessionId: string, m: ChatServerMessage): void {
+  // Items come from the worker, which writes them a moment after saying so.
+  if (m.type === "state" || m.type === "compacting" || m.type === "item")
+    markStatusDirty(sessionId, EMIT_SETTLE_MS);
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/runner.ts

@@ -38,7 +38,6 @@ import {
   hasItem,
   itemsOfKind,
   recentTasks,
-  listItems,
   saveItem,
   settle,
 } from "./store";
@@ -851,17 +850,11 @@ function present(sessionId: string, items: ChatItem[]): ChatItem[] {
   return runningWorkers().includes(sessionId) ? items : settle(items);
 }
 
-// Snapshot then live updates. Returns the unsubscribe function. `paged`
-// clients get the latest page and ask for the rest; others get everything.
-export function watchChat(
-  sessionId: string,
-  listener: Listener,
-  paged = false
-): () => void {
+// Snapshot then live updates. Returns the unsubscribe function. Every
+// client gets the latest page and asks for older ones.
+export function watchChat(sessionId: string, listener: Listener): () => void {
   const live = registry.live.get(sessionId);
-  const page = paged
-    ? readPage(sessionId)
-    : { items: listItems(sessionId), cursor: null, hasMore: false };
+  const page = readPage(sessionId);
   const onPage = new Set(page.items.map((i) => i.id));
   // The composer lists background work still going or just done, even when
   // it started before the page.

package/lib/chat/socket.ts

@@ -102,17 +102,16 @@ export function serveChatSocket(
   // A linked machine's session: its own AgentOS serves the chat.
   const link = demo ? null : peerChatLink(sessionId);
   if (link) {
-    const paged = params.get("paged");
     return relayChatSocket(
       ws,
       link,
-      { session: sessionId, ...(paged && { paged }) },
+      { session: sessionId, paged: "1" },
       send,
       (message) => reply(errorItem(message))
     );
   }
   try {
-    unwatch = watchChat(sessionId, reply, params.get("paged") === "1");
+    unwatch = watchChat(sessionId, reply);
   } catch (err) {
     fail(err);
     if (!closed) ws.close();

package/lib/chat/store.ts

@@ -1,5 +1,6 @@
 import { db } from "../db";
 import type { ChatItem } from "./events";
+import { markStatusDirty } from "../status/dirty";
 
 // Items keep the position they were first written at, so replacing one
 // (a finished tool call, a streamed message's final text) never reorders.
@@ -11,6 +12,7 @@ export function saveItem(sessionId: string, item: ChatItem): void {
      ON CONFLICT(session_id, item_id) DO UPDATE SET data = excluded.data`
   ).run(sessionId, item.id, sessionId, JSON.stringify(item));
   seqs.delete(sessionId);
+  markStatusDirty(sessionId);
 }
 
 // The streaming path. Every update of an item is a write, so they're held
@@ -79,6 +81,7 @@ export function flushItems(): void {
         for (const [itemId, p] of items)
           insert.run(sessionId, itemId, p.seq, p.data);
     })();
+    for (const sessionId of pending.keys()) markStatusDirty(sessionId);
     pending.clear();
   } catch (error) {
     // Kept for the next try rather than lost.
@@ -96,6 +99,7 @@ export function moveToEnd(sessionId: string, itemId: string): void {
      WHERE session_id = ? AND item_id = ?`
   ).run(sessionId, sessionId, itemId);
   seqs.delete(sessionId);
+  markStatusDirty(sessionId);
 }
 
 export function listItems(sessionId: string): ChatItem[] {
@@ -198,26 +202,32 @@ export function recentTasks(
     .map((r) => JSON.parse(r.data));
 }
 
-// Tool calls saved as still running.
-export function runningTools(
-  sessionId: string
-): Extract<ChatItem, { kind: "tool" }>[] {
+// Items of a kind saved as still running, read from the running index.
+export function runningItems<K extends "tool" | "task">(
+  sessionId: string,
+  kind: K
+): Extract<ChatItem, { kind: K }>[] {
   flushItems();
   return (
     db
       .prepare(
         `SELECT data FROM chat_items WHERE session_id = ?
-         AND kind = 'tool'
-         AND json_extract(data, '$.status') = 'running'`
+         AND kind = ? AND json_extract(data, '$.status') = 'running'
+         ORDER BY seq`
       )
-      .all(sessionId) as { data: string }[]
+      .all(sessionId, kind) as { data: string }[]
   ).map((r) => JSON.parse(r.data));
 }
 
+// Tool calls saved as still running.
+export const runningTools = (sessionId: string) =>
+  runningItems(sessionId, "tool");
+
 export function deleteItems(sessionId: string): void {
   pending.delete(sessionId);
   seqs.delete(sessionId);
   db.prepare(`DELETE FROM chat_items WHERE session_id = ?`).run(sessionId);
+  markStatusDirty(sessionId);
 }
 
 // With no live conversation, nothing is still streaming or running: those

package/lib/db/migrations.ts

@@ -1617,6 +1617,19 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 70,
+    name: "chat_items_running",
+    up: (db) => {
+      // What is still running (tools, background tasks) is read on every
+      // attach; the index holds only those rows, so it's a lookup, not a
+      // scan that parses every tool output of a long conversation.
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_chat_items_running ON chat_items(session_id, kind, seq)
+         WHERE json_extract(data, '$.status') = 'running'`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/demo-reseed.ts

@@ -9,6 +9,7 @@ import fs from "fs";
 import type Database from "better-sqlite3";
 import { notifyStatusChanged } from "./status/hub";
 import { resetDemoChat } from "./chat/demo";
+import { markAllStatusDirty } from "./status/dirty";
 
 export const RESEED_MS = 10 * 60 * 1000;
 
@@ -92,6 +93,7 @@ export function startDemoReseed(
     try {
       restoreDemo(db, file);
       resetDemoChat();
+      markAllStatusDirty();
       notifyStatusChanged();
       onRestored();
     } catch (error) {

package/lib/orchestrator/armed.ts

@@ -26,6 +26,7 @@ import { isPaused } from "./pause";
 import { review } from "./review";
 import { judge, mergeJudged } from "./signoff";
 import { workspaceTask } from "./targets";
+import { markStatusDirty } from "../status/dirty";
 
 // Judged again at least this often, for what the fingerprint can't see.
 export const ARMED_RECHECK_MS = 5 * 60 * 1000;
@@ -38,6 +39,7 @@ export function setArmed(sessionId: string, armed: boolean): void {
        merge_armed_seen = NULL WHERE id = ?`
   ).run(sessionId);
   looked.delete(sessionId);
+  markStatusDirty(sessionId);
   notifyStatusChanged();
 }
 

package/lib/orchestrator/checks.ts

@@ -6,6 +6,7 @@
 
 import { db } from "../db";
 import { notifyStatusChanged } from "../status/hub";
+import { markAllStatusDirty, markStatusDirty } from "../status/dirty";
 
 // ci: when the check count on a commit last changed, for settling.
 export type CheckKind = "review" | "scope" | "ci";
@@ -58,6 +59,7 @@ export function putCheck(row: {
     row.status,
     row.detail ?? null
   );
+  markStatusDirty(row.sessionId);
   notifyStatusChanged();
   return getCheck(row.sessionId, row.sha, row.kind)!;
 }
@@ -68,4 +70,5 @@ export function clearStaleRunning(maxAgeMinutes = 30): void {
     `UPDATE orchestrator_checks SET status = 'error', detail = 'Interrupted: run it again'
      WHERE status = 'running' AND created_at < datetime('now', ?)`
   ).run(`-${maxAgeMinutes} minutes`);
+  markAllStatusDirty();
 }

package/lib/orchestrator/facts.ts

@@ -20,6 +20,7 @@ import { storedPR } from "../tasks/session";
 import { commitTime, repoOf } from "./repo";
 import { CHECKLESS_MS, checklessFor, ciSettleIn } from "./task-state";
 import { repoHasCI } from "./repo-ci";
+import { markStatusDirty } from "../status/dirty";
 
 export type FactStatus = "running" | "waiting" | "idle" | "dead";
 
@@ -211,7 +212,10 @@ export async function settleIn(
   let at = committed.get(pr.head);
   if (at === undefined) {
     at = await commitTime(repoOf(s), pr.head).catch(() => 0);
-    if (at) committed.set(pr.head, at);
+    if (at) {
+      committed.set(pr.head, at);
+      markStatusDirty(s.id);
+    }
   }
   return ciSettleIn({
     workspaceId,

package/lib/orchestrator/gates.ts

@@ -18,6 +18,7 @@ import type { CheckRow } from "./checks";
 import { APPROVAL_GATES, mergeApprovalsOn } from "./merge-approvals";
 import type { RepoCI } from "./repo-ci";
 import { untrusted } from "./untrusted";
+import { markStatusDirty } from "../status/dirty";
 
 export type GateName =
   | "ci"
@@ -244,6 +245,7 @@ function countOnce(
          last_reason = excluded.last_reason,
          last_sha = excluded.last_sha`
   ).run(sessionId, gate, workspaceId, reason, sha, fresh ? 1 : 0);
+  markStatusDirty(sessionId);
   return failureOf(sessionId, gate)!.count;
 }
 
@@ -261,6 +263,7 @@ export function markEscalated(sessionId: string, gate: string): void {
   db.prepare(
     `UPDATE orchestrator_gate_failures SET escalated_at = datetime('now') WHERE session_id = ? AND gate = ?`
   ).run(sessionId, gate);
+  markStatusDirty(sessionId);
 }
 
 export function escalations(sessionId: string): FailureRow[] {

package/lib/orchestrator/merge-approvals.ts

@@ -7,6 +7,7 @@
  */
 
 import { db } from "../db";
+import { markAllStatusDirty } from "../status/dirty";
 
 const KEY = "orchestrator.merge_approvals";
 
@@ -26,4 +27,5 @@ export function setMergeApprovals(on: boolean): void {
     `INSERT INTO settings (key, value) VALUES (?, ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value`
   ).run(KEY, on ? "1" : "0");
+  markAllStatusDirty();
 }

package/lib/status/collect.ts

@@ -19,7 +19,8 @@ import {
   getProviderIdFromSessionName,
   getSessionIdFromName,
 } from "../providers/registry";
-import { getDb, type Session } from "../db";
+import { getDb } from "../db";
+import { beginPass, chatMemo } from "./incremental";
 import { chatCompacting, chatState } from "../chat/runner";
 import { chatActivityLine, chatStall } from "../chat/activity";
 import {
@@ -243,32 +244,16 @@ function getAgentTypeFromSessionName(sessionName: string): AgentType {
   return getProviderIdFromSessionName(sessionName) || "claude";
 }
 
-function terminalRow(db: ReturnType<typeof getDb>, id: string) {
-  return db
-    .prepare(
-      `SELECT id, view, updated_at, last_seen_at FROM sessions WHERE id = ?`
-    )
-    .get(id) as
-    | Pick<Session, "id" | "view" | "updated_at" | "last_seen_at">
-    | undefined;
-}
-
-async function collect(): Promise<StatusSnapshot> {
+async function collect(full = false): Promise<StatusSnapshot> {
   const sessions = await getTmuxSessions();
 
   const db = getDb();
+  // Read once the sessions are listed, so what was kept is as new as it.
+  const pass = beginPass(Date.now(), full);
+  const rows = [...pass.rows.values()];
   const panes = managedPanes(
     sessions,
-    db
-      .prepare(
-        `SELECT id, tmux_name, agent_type, host_id FROM sessions WHERE archived_at IS NULL AND (view IS NULL OR view != 'chat')`
-      )
-      .all() as {
-      id: string;
-      tmux_name: string | null;
-      agent_type: string | null;
-      host_id: string | null;
-    }[],
+    rows.filter((s) => s.view !== "chat"),
     (name) => UUID_PATTERN.test(name),
     getSessionIdFromName
   );
@@ -351,7 +336,7 @@ async function collect(): Promise<StatusSnapshot> {
     lastLine,
     agentType,
   } of results) {
-    const row = terminalRow(db, id);
+    const row = pass.rows.get(id);
     const shared = {
       sessionName,
       lastLine,
@@ -418,6 +403,8 @@ async function collect(): Promise<StatusSnapshot> {
   // Update claude_session_id directly here instead of requiring separate API calls
   for (const { id, claudeSessionId, agentType } of results) {
     if (!claudeSessionId) continue;
+    // Already stored (as the rows above read it): nothing to write.
+    if (pass.rows.get(id)?.claude_session_id === claudeSessionId) continue;
     if (agentType === "claude")
       updateClaudeIdStmt.run(claudeSessionId, id, claudeSessionId);
     else
@@ -432,14 +419,9 @@ async function collect(): Promise<StatusSnapshot> {
 
   // A linked machine's sessions: its AgentOS says how they are.
   const linked = linkedHostIds();
-  const mirrors = (
-    db
-      .prepare(
-        `SELECT id, tmux_name, agent_type, host_id FROM sessions
-          WHERE archived_at IS NULL AND host_id IS NOT NULL AND host_id != 'local'`
-      )
-      .all() as Pick<Session, "id" | "tmux_name" | "agent_type" | "host_id">[]
-  ).filter((s) => linked.has(s.host_id));
+  const mirrors = rows.filter(
+    (s) => s.host_id && s.host_id !== "local" && linked.has(s.host_id)
+  );
   for (const s of mirrors) {
     const status = peerStatus(s.host_id, s.id);
     if (status)
@@ -452,36 +434,39 @@ async function collect(): Promise<StatusSnapshot> {
 
   // Chat sessions have no tmux pane: their live conversation is the status.
   // A linked machine's chats are its own (above).
-  for (const session of db
-    .prepare(
-      `SELECT * FROM sessions WHERE view = 'chat' AND archived_at IS NULL
-         AND (host_id IS NULL OR host_id = 'local')`
-    )
-    .all() as Session[]) {
+  for (const session of rows.filter(
+    (s) => s.view === "chat" && (!s.host_id || s.host_id === "local")
+  )) {
     const state = chatState(session.id);
-    const asks =
-      session.role === "orchestrator" ? openAskCount(session.workspace_id) : 0;
+    const orchestrator = session.role === "orchestrator";
+    // What the database says; the rest below moves with time or the process.
+    const base = chatMemo(pass, session.id, orchestrator, state ?? "", () => {
+      const asks = orchestrator ? openAskCount(session.workspace_id) : 0;
+      return {
+        asks,
+        waiting: needsYou(session, state),
+        need: chatNeed(session, state, asks),
+        unread: isUnread(session, state),
+        lastTask: lastUserTask(session.id),
+      };
+    });
     statusMap[session.id] = {
       sessionName: session.tmux_name,
       status:
-        state === "running"
-          ? "running"
-          : needsYou(session, state)
-            ? "waiting"
-            : "idle",
-      task: chatActivityLine(session.id) ?? lastUserTask(session.id),
+        state === "running" ? "running" : base.waiting ? "waiting" : "idle",
+      task: chatActivityLine(session.id) ?? base.lastTask,
       agentType: session.agent_type,
-      need: chatNeed(session, state, asks),
-      unread: isUnread(session, state),
+      need: base.need,
+      unread: base.unread,
       ...(chatStall(session.id) && { stalled: true }),
       ...(chatCompacting(session.id) && {
         compacting: chatCompacting(session.id)!,
       }),
-      ...(session.role === "orchestrator" && { asks }),
+      ...(orchestrator && { asks: base.asks }),
     };
   }
 
-  addPrStages(statusMap);
+  addPrStages(statusMap, pass);
 
   // Cleanup old trackers
   statusDetector.cleanup();
@@ -492,8 +477,11 @@ async function collect(): Promise<StatusSnapshot> {
 // Callers at the same moment share one pass over tmux.
 let inflight: Promise<StatusSnapshot> | null = null;
 
-export function collectStatuses(): Promise<StatusSnapshot> {
-  inflight ??= collect().finally(() => {
+/** `full`: recompute everything kept from earlier passes. */
+export function collectStatuses({
+  full = false,
+}: { full?: boolean } = {}): Promise<StatusSnapshot> {
+  inflight ??= collect(full).finally(() => {
     inflight = null;
   });
   return inflight;

package/lib/status/dirty.ts

@@ -0,0 +1,42 @@
+// Which sessions' status inputs changed since the last pass, so a pass
+// recomputes those and reuses the rest (lib/status/incremental.ts). Marked
+// from the places that write them. No imports, so any module can call it.
+//
+// Shared by the custom server and the Next.js route bundles.
+interface Dirty {
+  all: boolean;
+  // A session's id and the time before which it stays marked.
+  ids: Map<string, number>;
+}
+
+const g = globalThis as unknown as { __agentosStatusDirty?: Dirty };
+const dirty: Dirty = (g.__agentosStatusDirty ??= {
+  all: false,
+  ids: new Map(),
+});
+
+/**
+ * `id`'s inputs changed. With `settleMs` it stays marked, so every pass
+ * recomputes it, until a pass at or after that time: a write still on its
+ * way (a worker's buffered chat items) can't be cached half-seen.
+ */
+export function markStatusDirty(id: string, settleMs = 0): void {
+  const until = Date.now() + settleMs;
+  dirty.ids.set(id, Math.max(dirty.ids.get(id) ?? 0, until));
+}
+
+/** Something every session's status may depend on changed. */
+export function markAllStatusDirty(): void {
+  dirty.all = true;
+}
+
+/** What a pass starting at `now` recomputes; the marks it settles are cleared. */
+export function takeDirty(now = Date.now()): {
+  all: boolean;
+  ids: Set<string>;
+} {
+  const taken = { all: dirty.all, ids: new Set(dirty.ids.keys()) };
+  dirty.all = false;
+  for (const [id, until] of dirty.ids) if (until <= now) dirty.ids.delete(id);
+  return taken;
+}

package/lib/status/incremental.ts

@@ -0,0 +1,151 @@
+// What a status pass keeps from the one before, so its cost follows what
+// changed and not how many sessions there are:
+//  - the session rows, re-read only when `sessions` or `projects` moved
+//    (lib/db/changes.ts: every writer is seen) and compared to find the
+//    sessions that changed;
+//  - per chat and per task, what is worked out from the database, recomputed
+//    when its session is marked dirty (lib/status/dirty.ts).
+// Every FULL_RECOMPUTE_MS a pass recomputes everything, so an invalidation
+// nobody made self-heals.
+import { getDb, type Session } from "../db";
+import { changeWatcher } from "../db/changes";
+import { takeDirty } from "./dirty";
+
+export const FULL_RECOMPUTE_MS = 30_000;
+
+// A session row, and the workspace of its project.
+export type SessionRow = Session & { project_workspace_id: string | null };
+
+export interface Pass {
+  // Everything is recomputed.
+  full: boolean;
+  // Sessions whose inputs changed (all of them on a full pass).
+  dirty: Set<string>;
+  // An orchestrator's asks changed: they and the tasks that read them.
+  asksMoved: boolean;
+  rows: Map<string, SessionRow>;
+}
+
+type Entry<T> = { key: string; value: T };
+
+interface Cache {
+  rows: Map<string, { row: SessionRow; json: string }>;
+  watch: (() => string[]) | null;
+  lastFullAt: number;
+  loaded: boolean;
+  chats: Map<string, Entry<unknown>>;
+  prs: Map<string, Entry<unknown>>;
+}
+
+const g = globalThis as unknown as { __agentosStatusCache?: Cache };
+const cache: Cache = (g.__agentosStatusCache ??= {
+  rows: new Map(),
+  watch: null,
+  lastFullAt: 0,
+  loaded: false,
+  chats: new Map(),
+  prs: new Map(),
+});
+
+/** Forget everything kept: the next pass computes it all. */
+export function resetStatusCaches(): void {
+  cache.rows.clear();
+  cache.chats.clear();
+  cache.prs.clear();
+  cache.watch = null;
+  cache.loaded = false;
+  cache.lastFullAt = 0;
+}
+
+function loadRows(dirty: Set<string>): void {
+  const rows = getDb()
+    .prepare(
+      `SELECT s.*, p.workspace_id AS project_workspace_id FROM sessions s
+         LEFT JOIN projects p ON p.id = s.project_id
+        WHERE s.archived_at IS NULL`
+    )
+    .all() as SessionRow[];
+  const before = cache.rows;
+  cache.rows = new Map();
+  for (const row of rows) {
+    const json = JSON.stringify(row);
+    if (before.get(row.id)?.json !== json) dirty.add(row.id);
+    cache.rows.set(row.id, { row, json });
+  }
+  for (const id of before.keys())
+    if (!cache.rows.has(id)) {
+      cache.chats.delete(id);
+      cache.prs.delete(id);
+    }
+}
+
+export function beginPass(now = Date.now(), forceFull = false): Pass {
+  // Read before the rows, so a write between the two is seen next time.
+  const moved = (cache.watch ??= changeWatcher(getDb))();
+  const taken = takeDirty(now);
+  const full =
+    forceFull ||
+    !cache.loaded ||
+    taken.all ||
+    now - cache.lastFullAt >= FULL_RECOMPUTE_MS;
+  const dirty = taken.ids;
+  if (full || moved.includes("sessions") || moved.includes("projects")) {
+    loadRows(dirty);
+    cache.loaded = true;
+  }
+  if (full) {
+    cache.chats.clear();
+    cache.prs.clear();
+    cache.lastFullAt = now;
+  }
+  return {
+    full,
+    dirty,
+    asksMoved: moved.includes("orchestrator_asks"),
+    rows: new Map([...cache.rows].map(([id, e]) => [id, e.row])),
+  };
+}
+
+function remembered<T>(
+  store: Map<string, Entry<unknown>>,
+  id: string,
+  stale: boolean,
+  key: string,
+  compute: () => { value: T; keep: boolean }
+): T {
+  const kept = store.get(id);
+  if (!stale && kept && kept.key === key) return kept.value as T;
+  const { value, keep } = compute();
+  if (keep) store.set(id, { key, value });
+  else store.delete(id);
+  return value;
+}
+
+/**
+ * A chat's database-derived status, from the last pass unless it changed.
+ * `key` is what else it was computed from (its state).
+ */
+export function chatMemo<T>(
+  pass: Pass,
+  id: string,
+  orchestrator: boolean,
+  key: string,
+  compute: () => T
+): T {
+  const stale =
+    pass.full || pass.dirty.has(id) || (orchestrator && pass.asksMoved);
+  return remembered(cache.chats, id, stale, key, () => ({
+    value: compute(),
+    keep: true,
+  }));
+}
+
+/** A task's PR stage; `compute` says whether it can be kept (time moves it). */
+export function prMemo<T>(
+  pass: Pass,
+  id: string,
+  compute: () => { value: T; keep: boolean }
+): T {
+  const stale = pass.full || pass.dirty.has(id) || pass.asksMoved;
+  return remembered(cache.prs, id, stale, "", compute);
+}

package/lib/status/pr-stages.ts

@@ -1,7 +1,6 @@
 // A task's PR stage for the sidebar, from state AgentOS already holds: the
 // PR as the last poll saw it, the stored review and CI checks, escalations,
 // asks and the armed flag. Nothing here asks GitHub.
-import { db, type Session } from "../db";
 import { cachedPR, storedPR } from "../tasks/session";
 import { derivePrStage } from "../tasks/pr-stage";
 import { getCheck } from "../orchestrator/checks";
@@ -9,30 +8,23 @@ import { holdingEscalations } from "../orchestrator/gates";
 import { openBySubject, workSubject } from "../orchestrator/asks";
 import { ciSettleLeft } from "../orchestrator/task-state";
 import { knownCommitTime } from "../orchestrator/facts";
+import { prMemo, type Pass } from "./incremental";
 import type { SessionStatusResponse } from "./collect";
 
-type TaskRow = Session & { workspace_id: string };
-
 export function addPrStages(
-  statuses: Record<string, SessionStatusResponse>
+  statuses: Record<string, SessionStatusResponse>,
+  pass: Pass
 ): void {
-  const tasks = db
-    .prepare(
-      `SELECT s.*, p.workspace_id FROM sessions s
-         JOIN projects p ON p.id = s.project_id
-        WHERE s.task_status = 'running' AND s.pr_number IS NOT NULL
-          AND s.archived_at IS NULL`
-    )
-    .all() as TaskRow[];
-  for (const t of tasks) {
+  for (const t of pass.rows.values()) {
+    if (t.task_status !== "running" || !t.pr_number || !t.project_id) continue;
     const status = statuses[t.id];
-    if (!status) continue;
-    try {
-      const pr = cachedPR(t.id) ?? storedPR(t);
-      const head = pr?.head;
-      const stage = derivePrStage({
-        pr,
-        settleIn:
+    if (!status || t.project_workspace_id === null) continue;
+    const workspaceId = t.project_workspace_id;
+    const stage = prMemo(pass, t.id, () => {
+      try {
+        const pr = cachedPR(t.id) ?? storedPR(t);
+        const head = pr?.head;
+        const settleIn =
           pr?.checks === "pass" && head
             ? ciSettleLeft({
                 taskId: t.id,
@@ -40,16 +32,27 @@ export function addPrStages(
                 checkCount: pr.checkCount ?? 0,
                 committedAt: knownCommitTime(head),
               })
-            : 0,
-        review: head ? (getCheck(t.id, head, "review")?.status ?? null) : null,
-        held:
-          holdingEscalations(t.id).length > 0 ||
-          !!openBySubject(t.workspace_id, workSubject(t.id)),
-        armed: !!t.merge_armed_at,
-      });
-      if (stage) status.prStage = stage;
-    } catch (error) {
-      console.error(`[status] PR stage of ${t.id.slice(0, 8)}:`, error);
-    }
+            : 0;
+        return {
+          value: derivePrStage({
+            pr,
+            settleIn,
+            review: head
+              ? (getCheck(t.id, head, "review")?.status ?? null)
+              : null,
+            held:
+              holdingEscalations(t.id).length > 0 ||
+              !!openBySubject(workspaceId, workSubject(t.id)),
+            armed: !!t.merge_armed_at,
+          }),
+          // Counting down to the end of the settle wait: time moves it.
+          keep: settleIn <= 0,
+        };
+      } catch (error) {
+        console.error(`[status] PR stage of ${t.id.slice(0, 8)}:`, error);
+        return { value: null, keep: false };
+      }
+    });
+    if (stage) status.prStage = stage;
   }
 }

package/lib/tasks/session.ts

@@ -18,6 +18,7 @@ import { lookupPR } from "./pr-poll";
 import { captureMergedTask } from "../session-logs";
 import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
+import { markStatusDirty } from "../status/dirty";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 
@@ -190,6 +191,7 @@ export async function prFor(
   if (renamed && !refused) moveBranch(session, renamed);
   const before = prCache.get(session.id)?.pr;
   prCache.set(session.id, { at: Date.now(), pr });
+  markStatusDirty(session.id);
   // A PR whose stage inputs moved is news for the sidebar's badge.
   if (prSignature(before) !== prSignature(pr)) notifyStatusChanged();
   if (pr) {
@@ -279,4 +281,5 @@ export function storedPR(s: Session): TaskPR | null {
 
 export function forgetPR(sessionId: string): void {
   prCache.delete(sessionId);
+  markStatusDirty(sessionId);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.512",
+  "version": "0.3.514",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"