@saadnvd1/agent-os 0.3.510 → 0.3.513

package/app/api/sessions/route.ts

@@ -13,13 +13,7 @@ export async function GET() {
     // Merged and dropped tasks live in the Tasks panel (a moved one lives on
     // the machine it moved to), archived sessions
     // in the Archived view: neither is in the sidebar.
-    const sessions = (queries.getAllSessions(db).all() as Session[]).filter(
-      (s) =>
-        !s.archived_at &&
-        s.task_status !== "merged" &&
-        s.task_status !== "dropped" &&
-        s.task_status !== "moved"
-    );
+    const sessions = queries.getSidebarSessions(db).all() as Session[];
     const groups = queries.getAllGroups(db).all() as Group[];
 
     // Convert expanded from 0/1 to boolean

package/components/Pane/index.tsx

@@ -305,7 +305,7 @@ export const Pane = memo(function Pane({
           sessionName={chat.name}
           accessLocked={chat.role === "orchestrator"}
           freshStart={
-            (chat.role === "orchestrator" || !!chat.task_brief) &&
+            (chat.role === "orchestrator" || !!chat.has_brief) &&
             !chat.archived_at
           }
           orchestratorOf={

package/components/SessionList/SessionRowMenu.tsx

@@ -175,7 +175,7 @@ export function SessionRowMenu({
           {summarizing ? "Summarizing..." : "Fresh start"}
         </Item>
       )}
-      {(session.role === "orchestrator" || session.task_brief) &&
+      {(session.role === "orchestrator" || session.has_brief) &&
         session.view === "chat" &&
         !session.archived_at &&
         !blocked && (

package/lib/away/activity.ts

@@ -116,6 +116,33 @@ function chatTurn(sessionId: string): number {
   );
 }
 
+// How recently Saad must have messaged an orchestrator for turning Away on
+// to tell it.
+export const SAAD_MESSAGE_WINDOW_MS = 24 * 60 * 60_000;
+
+// When Saad last typed to a chat himself: a user item with no origin, so
+// not an event, a peer, a schedule or AgentOS, or his own decision made
+// outside the composer. 0 when he never has.
+function saadMessageAt(sessionId: string): number {
+  const row = db
+    .prepare(
+      `SELECT json_extract(data, '$.createdAt') AS at FROM chat_items
+       WHERE session_id = ? AND kind = 'user'
+         AND (json_extract(data, '$.origin') IS NULL
+           OR json_extract(data, '$.origin.kind') = 'decision')
+       ORDER BY seq DESC LIMIT 1`
+    )
+    .get(sessionId) as { at: number | null } | undefined;
+  return row?.at ?? 0;
+}
+
+// Whether Saad has been talking to this session lately. A terminal keeps
+// no record of who typed, so its last turn stands in.
+export function saadMessagedRecently(s: Session, now = Date.now()): boolean {
+  const at = s.view === "chat" ? saadMessageAt(s.id) : terminalTurn(s);
+  return at > 0 && now - at <= SAAD_MESSAGE_WINDOW_MS;
+}
+
 // A terminal's Claude conversation file is written on every turn and on
 // nothing else; other agents fall back to tmux's output clock, which a
 // status poll (capture-pane) doesn't move.

package/lib/away/brief.ts

@@ -7,7 +7,6 @@ import {
   activeAway,
   clockTime,
   fromSql,
-  reachedWorkspaces,
   untilText,
   type AwayRow,
 } from "./state";
@@ -18,14 +17,9 @@ export function awayOnLine(row: AwayRow, now = Date.now()): string {
   return `Saad is away (Away mode, since ${clockTime(fromSql(row.started_at), now)}, ${untilText(row, now)}). Follow work through rather than only reacting to events: keep each task moving to merged and deployed, sign off what passes its gates, and pick up what stalled. Every ${SWEEP_EVERY_MS / 60000} minutes AgentOS sweeps this workspace without messaging any session: it runs lost reviews again, checks the deploy after each merge, and sends you one digest of what's new (stalled tasks, idle ones with uncommitted work and no PR, Saad's own sessions idle with uncommitted work). You decide what needs work and act with your tools. Only sessions with real activity in the last ${awayWindowMinutes()} minutes are listed: leave the rest alone, since a message wakes an agent and re-reads its whole context. Interactive sessions (not tasks) are Saad's: ask a listed one at most once to wrap up, never drive them further. Hard lines still go to ask_saad; while he's away his asks reach his phone in one batch per sweep, so raise them as usual. \`aos notify\` is held for that batch too, so don't send one per item.`;
 }
 
-// For the digest: the same line while Away is on and has reached this
-// workspace, else nothing.
-export function awayDigestLine(
-  workspaceId: string,
-  now = Date.now()
-): string | null {
+// For the digest: the same line whenever Away is on, messaged or not, so an
+// orchestrator skipped at the toggle still knows when it next starts.
+export function awayDigestLine(now = Date.now()): string | null {
   const row = activeAway();
-  return row && reachedWorkspaces(row.id).has(workspaceId)
-    ? awayOnLine(row, now)
-    : null;
+  return row ? awayOnLine(row, now) : null;
 }

package/lib/away/run.ts

@@ -45,7 +45,12 @@ import {
   SWEEP_EVERY_MS,
   type Candidate,
 } from "./sweep";
-import { agentLive, awayWindowMs, lastTurnAt } from "./activity";
+import {
+  agentLive,
+  awayWindowMs,
+  lastTurnAt,
+  saadMessagedRecently,
+} from "./activity";
 import { checkDeploy } from "./deploy";
 import { buildAwayReport, phoneSummary, reportMarkdown } from "./report";
 import { awayOnLine } from "./brief";
@@ -92,6 +97,14 @@ function tellAway(
   // keep an orchestrator going that nothing else has.
   if (!orchestratorActive(orchestratorId, now)) return false;
   const told = reachedWorkspaces(away.id).has(workspaceId);
+  // A first message goes only to one Saad has messaged lately: waking the
+  // rest re-reads their whole context for nothing, and they read the away
+  // state in their brief when they next start. One already told keeps its
+  // sweeps for the rest of the period.
+  if (!told) {
+    const s = sessionRow(orchestratorId);
+    if (!s || !saadMessagedRecently(s, now)) return false;
+  }
   // One transaction: a crash can't leave the marker set with the event
   // never queued.
   db.transaction(() => {
@@ -133,8 +146,9 @@ export function turnAwayOn(
 ): AwayRow {
   const { row, started } = startAway(input, now);
   // Sent again when the end moves, so the orchestrator has the new one.
-  for (const { workspaceId, orchestratorId } of orchestrated())
+  for (const { workspaceId, orchestratorId } of orchestrated()) {
     tellAway(row, workspaceId, orchestratorId, now, !started);
+  }
   return row;
 }
 

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

@@ -37,7 +37,7 @@ import {
   getItem,
   hasItem,
   itemsOfKind,
-  listItems,
+  recentTasks,
   saveItem,
   settle,
 } from "./store";
@@ -850,26 +850,16 @@ 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.
   const recent = Date.now() - 60 * 60 * 1000;
-  const tasks = itemsOfKind(sessionId, "task").filter(
-    (t) =>
-      !onPage.has(t.id) &&
-      (t.status === "running" || (t.endedAt ?? t.createdAt) > recent)
-  );
+  const tasks = recentTasks(sessionId, recent).filter((t) => !onPage.has(t.id));
   listener({
     type: "snapshot",
     items: present(sessionId, page.items),

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

@@ -176,22 +176,49 @@ export function itemsOfKind<K extends ChatItem["kind"]>(
   ).map((r) => JSON.parse(r.data));
 }
 
-// Tool calls saved as still running.
-export function runningTools(
-  sessionId: string
-): Extract<ChatItem, { kind: "tool" }>[] {
+// A chat's background tasks still running, or ended after `since` (ms): what
+// the composer lists, read without parsing the rest of a long conversation.
+export function recentTasks(
+  sessionId: string,
+  since: number
+): Extract<ChatItem, { kind: "task" }>[] {
+  flushItems();
+  return (
+    db
+      .prepare(
+        `SELECT data FROM chat_items WHERE session_id = ? AND kind = 'task'
+         AND (json_extract(data, '$.status') = 'running'
+              OR COALESCE(json_extract(data, '$.endedAt'),
+                          json_extract(data, '$.createdAt')) > ?)
+         ORDER BY seq DESC LIMIT 200`
+      )
+      .all(sessionId, since) as { data: string }[]
+  )
+    .reverse()
+    .map((r) => JSON.parse(r.data));
+}
+
+// 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/index.ts

@@ -6,7 +6,7 @@ import { runMigrations } from "./migrations";
 
 // Re-export types and queries
 export * from "./types";
-export { queries } from "./queries";
+export { queries, sessionListColumns } from "./queries";
 export * from "./lumifyhub";
 export * from "./lumifyhub-docs";
 export * from "./stacks";

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/db/queries.ts

@@ -13,6 +13,28 @@ function getStmt(db: Database.Database, sql: string): Database.Statement {
   return stmt;
 }
 
+// Every sessions column but the two large text ones, which only the single
+// session paths read; a list gets has_brief for whether a brief exists.
+const listColumns = new WeakMap<Database.Database, string>();
+export function sessionListColumns(db: Database.Database, alias = ""): string {
+  let cols = listColumns.get(db);
+  if (!cols) {
+    cols = (
+      db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+    )
+      .map((c) => c.name)
+      .filter((n) => n !== "task_brief" && n !== "system_prompt")
+      .join(",");
+    listColumns.set(db, cols);
+  }
+  const prefix = alias ? `${alias}.` : "";
+  const list = cols
+    .split(",")
+    .map((c) => `${prefix}${c}`)
+    .join(", ");
+  return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief`;
+}
+
 export const queries = {
   // Sessions
   createSession: (db: Database.Database) =>
@@ -26,7 +48,22 @@ export const queries = {
     getStmt(db, `SELECT * FROM sessions WHERE id = ?`),
 
   getAllSessions: (db: Database.Database) =>
-    getStmt(db, `SELECT * FROM sessions ORDER BY updated_at DESC`),
+    getStmt(
+      db,
+      `SELECT ${sessionListColumns(db)} FROM sessions ORDER BY updated_at DESC`
+    ),
+
+  // The sidebar's sessions: not archived, and not a task that is over or
+  // lives on another machine.
+  getSidebarSessions: (db: Database.Database) =>
+    getStmt(
+      db,
+      `SELECT ${sessionListColumns(db)} FROM sessions
+         WHERE archived_at IS NULL
+           AND (task_status IS NULL
+                OR task_status NOT IN ('merged', 'dropped', 'moved'))
+         ORDER BY updated_at DESC`
+    ),
 
   // The tmux names AgentOS owns, for telling discovered sessions apart.
   getManagedTmuxNames: (db: Database.Database) =>

package/lib/db/types.ts

@@ -51,6 +51,8 @@ export interface Session {
   setup_ms?: number | null;
   setup_error?: string | null;
   task_brief?: string | null;
+  // Lists carry this instead of the brief itself (0/1).
+  has_brief?: number;
   // How the session is shown: a chat conversation or a terminal.
   view: "chat" | "terminal";
   chat_access: ChatAccess;

package/lib/done/archive.ts

@@ -44,7 +44,8 @@ export function unarchiveSession(id: string): Session {
 export function listArchived(workspaceId?: string): ArchivedView[] {
   const rows = db
     .prepare(
-      `SELECT s.*, p.name AS project_name, p.workspace_id AS project_workspace
+      `SELECT s.id, s.name, s.project_id, s.view, s.task_status, s.branch_name,
+         s.pr_url, s.worktree_path, s.archived_at, p.name AS project_name, p.workspace_id AS project_workspace
        FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
        WHERE s.archived_at IS NOT NULL
          AND (? IS NULL OR p.workspace_id = ?)

package/lib/needs-you.ts

@@ -56,7 +56,7 @@ function pendingApproval(
   const row = getDb()
     .prepare(
       `SELECT data FROM chat_items WHERE session_id = ?
-         AND json_extract(data, '$.kind') = 'approval'
+         AND kind = 'approval'
          AND json_extract(data, '$.status') = 'pending'
        ORDER BY seq DESC LIMIT 1`
     )

package/lib/orchestrator/digest.ts

@@ -324,7 +324,7 @@ export function buildDigest(
 ): string {
   const checks = checksBySession(workspaceId);
   const failures = failuresBySession(workspaceId);
-  const away = awayDigestLine(workspaceId);
+  const away = awayDigestLine();
   const head = `## Where things stand (read from AgentOS's database as you started)${away ? `\n\n${away}` : ""}`;
   const body = renderDigest(
     [

package/lib/tasks/index.ts

@@ -410,7 +410,7 @@ export function movedTasks(): { id: string; movedTo: string | null }[] {
 
 // Archived tasks aren't listed.
 export async function listTasks(): Promise<TaskView[]> {
-  const sessions = taskSessions().filter((s) => !s.archived_at);
+  const sessions = taskSessions(false);
   const [local, remote] = await Promise.all([
     Promise.all(sessions.filter((s) => !isMirror(s)).map(taskView)),
     remoteTaskViews(sessions.filter(isMirror)),

package/lib/tasks/session.ts

@@ -1,6 +1,12 @@
 import fs from "fs";
 import os from "os";
-import { db, queries, stackQueries, type Session } from "../db";
+import {
+  db,
+  queries,
+  sessionListColumns,
+  stackQueries,
+  type Session,
+} from "../db";
 import { getDefaultBranch, isBranchName } from "../git";
 import { parentBranchOf } from "../stacks/guard";
 import { voidApprovalsOn } from "../orchestrator/ask-approvals";
@@ -15,10 +21,14 @@ import type { TaskPR } from "./state";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 
-export function taskSessions(): Session[] {
+// Without the brief and system prompt: a list doesn't need them.
+export function taskSessions(includeArchived = true): Session[] {
   return db
     .prepare(
-      `SELECT * FROM sessions WHERE task_status IS NOT NULL AND task_status != 'moved' ORDER BY created_at DESC`
+      `SELECT ${sessionListColumns(db)} FROM sessions
+         WHERE task_status IS NOT NULL AND task_status != 'moved'
+           ${includeArchived ? "" : "AND archived_at IS NULL"}
+         ORDER BY created_at DESC`
     )
     .all() as Session[];
 }

package/package.json

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