@saadnvd1/agent-os 0.3.512 → 0.3.513

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/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

@@ -198,22 +198,27 @@ 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);

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/package.json

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