@saadnvd1/agent-os 0.3.673 → 0.3.680

package/lib/bus/read-scope.ts

@@ -0,0 +1,109 @@
+import { db } from "../db";
+import type { Session } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { previousNames } from "../session-names";
+import { resolveRef, type Candidate } from "./resolve";
+
+export type ReadableSession = Session & { project_name: string | null };
+
+export interface ReaderScope {
+  workspaceId: string | null;
+  projectId: string | null;
+  label: string;
+}
+
+// What the asking session may read: its workspace, or its project when it
+// has none. The boundary the orchestrator's tools use.
+export function readerScope(callerId: string): ReaderScope {
+  const caller = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(callerId) as Session | undefined;
+  if (!caller) throw new Error("aos read runs from inside an AgentOS session");
+  const project = caller.project_id ? getProject(caller.project_id) : null;
+  const workspaceId =
+    caller.workspace_id ?? (project && project.workspace_id) ?? null;
+  if (workspaceId)
+    return {
+      workspaceId,
+      projectId: null,
+      label: `workspace ${getWorkspace(workspaceId)?.name ?? workspaceId}`,
+    };
+  if (!project || project.is_uncategorized)
+    throw new Error(`${caller.name} isn't in a project`);
+  return {
+    workspaceId: null,
+    projectId: project.id,
+    label: `project ${project.name}`,
+  };
+}
+
+const SELECT = `SELECT s.*, p.name AS project_name FROM session_rows s
+  LEFT JOIN projects p ON p.id = s.project_id
+  WHERE s.peer_mirror = 0 AND s.held_by_device IS NULL`;
+
+const isLive = (s: Session) =>
+  !s.archived_at && (!s.task_status || s.task_status === "running");
+
+function candidates(rows: ReadableSession[]): Candidate[] {
+  const old = previousNames();
+  return rows.map((s) => ({
+    id: s.id,
+    name: s.name,
+    projectName: s.project_name,
+    tmuxName: s.tmux_name,
+    previousNames: old.get(s.id) ?? [],
+  }));
+}
+
+function inScope(s: ReadableSession, scope: ReaderScope): boolean {
+  if (s.role) return false;
+  if (scope.workspaceId) {
+    const p = s.project_id ? getProject(s.project_id) : null;
+    return !!p && p.workspace_id === scope.workspaceId;
+  }
+  return s.project_id === scope.projectId;
+}
+
+export type Readable =
+  | { ok: true; session: ReadableSession; note?: string }
+  | { ok: false; external: boolean; error: string };
+
+// A session in the caller's scope by name, old name, project/name, id or id
+// prefix. Done, dropped and archived ones count, but a live session wins a
+// name over a finished one.
+export function resolveReadable(callerId: string, ref: string): Readable {
+  const scope = readerScope(callerId);
+  const all = (db.prepare(SELECT).all() as ReadableSession[]).sort((a, b) =>
+    a.updated_at < b.updated_at ? 1 : -1
+  );
+  const mine = all.filter((s) => inScope(s, scope));
+  let none = "";
+  for (const group of [mine.filter(isLive), mine.filter((s) => !isLive(s))]) {
+    const r = resolveRef(ref, candidates(group));
+    if (r.ok) {
+      const session = group.find((s) => s.id === r.id)!;
+      if (session.id === callerId)
+        return { ok: false, external: false, error: "that's this session" };
+      return { ok: true, session, note: r.note };
+    }
+    if (r.reason === "ambiguous")
+      return { ok: false, external: false, error: r.error };
+    none = r.error;
+  }
+  const other = resolveRef(
+    ref,
+    candidates(all.filter((s) => !mine.includes(s)))
+  );
+  if (other.ok) {
+    const s = all.find((x) => x.id === other.id)!;
+    return {
+      ok: false,
+      external: false,
+      error: s.role
+        ? `${s.name} is an orchestrator: it isn't readable. Message it with aos send`
+        : `"${ref}" isn't in your ${scope.label}; aos read reaches only sessions there`,
+    };
+  }
+  return { ok: false, external: true, error: `${none}. Run: aos peers` };
+}

package/lib/bus/read.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+import { db } from "../db";
+import type { Session } from "../db";
+import { lastItems, listItems } from "../chat/store";
+import { untrusted } from "../orchestrator/untrusted";
+import { readExternal, readResolved } from "../orchestrator/read";
+import { findExternalSession } from "../orchestrator/external-sessions";
+import { pieceOfSession, planPathOf } from "../plans/features";
+import { hostLink } from "../hosts/remote-api";
+import {
+  readerScope,
+  resolveReadable,
+  type ReadableSession,
+} from "./read-scope";
+import {
+  READ_DEFAULT_TURNS,
+  TERMINAL_LINES,
+  TERMINAL_LINES_ALL,
+  condenseItems,
+  grepTurns,
+  renderTurns,
+  type Rendered,
+} from "./condense";
+
+export interface ReadOpts {
+  turns?: number;
+  lines?: number;
+  all?: boolean;
+  grep?: string;
+}
+
+export interface ReadResult {
+  // Ours, not another session's text: who, what state, how much.
+  header: string;
+  // Another session's text, fenced and redacted.
+  text: string;
+  session: { id: string | null; name: string; project: string | null };
+  task: { prompt: string | null; plan: string | null } | null;
+  turns: { from: number; to: number; total: number } | null;
+  truncated: boolean;
+}
+
+const PLAN_FILE = ".agentos/plan.md";
+const PROMPT_CAP = 1500;
+// Items fetched per turn asked for, when the whole chat isn't needed.
+const ITEMS_PER_TURN = 400;
+
+export class ReadError extends Error {
+  constructor(
+    message: string,
+    readonly status: number
+  ) {
+    super(message);
+  }
+}
+
+function stateOf(s: Session): string {
+  if (s.archived_at) return "archived";
+  return s.task_status ?? "running";
+}
+
+function planOf(s: Session): string | null {
+  if (s.worktree_path) {
+    const own = path.join(s.worktree_path, PLAN_FILE);
+    if (fs.existsSync(own)) return own;
+  }
+  const piece = pieceOfSession(s.id);
+  const fromFeature = piece ? planPathOf(piece.feature_id) : null;
+  return fromFeature && fs.existsSync(fromFeature) ? fromFeature : null;
+}
+
+function taskHeader(s: Session, all: boolean) {
+  if (!s.task_prompt) return null;
+  const p = s.task_prompt.trim();
+  return {
+    prompt: !all && p.length > PROMPT_CAP ? `${p.slice(0, PROMPT_CAP)}…` : p,
+    plan: planOf(s),
+  };
+}
+
+function userCount(sessionId: string): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM chat_items WHERE session_id = ? AND kind = 'user'`
+      )
+      .get(sessionId) as { n: number }
+  ).n;
+}
+
+function chatTurns(s: Session, o: ReadOpts) {
+  const total = userCount(s.id);
+  if (o.all || o.grep) return { turns: condenseItems(listItems(s.id)), total };
+  const asked = o.lines
+    ? Math.ceil(o.lines / 4) + 1
+    : (o.turns ?? READ_DEFAULT_TURNS);
+  const items = lastItems(s.id, Math.min(asked * ITEMS_PER_TURN, 4000));
+  const inWindow = items.filter((i) => i.kind === "user").length;
+  return { turns: condenseItems(items, Math.max(total - inWindow, 0)), total };
+}
+
+// What a session in the caller's workspace said and did, condensed.
+export async function readPeer(
+  callerId: string,
+  ref: string,
+  o: ReadOpts = {}
+): Promise<ReadResult> {
+  let found;
+  try {
+    found = resolveReadable(callerId, ref);
+  } catch (error) {
+    throw new ReadError(
+      error instanceof Error ? error.message : String(error),
+      403
+    );
+  }
+  if (!found.ok) {
+    const scope = readerScope(callerId);
+    const external =
+      found.external && scope.workspaceId
+        ? await findExternalSession(scope.workspaceId, ref).catch(() => null)
+        : null;
+    if (external) {
+      const n = o.lines ?? (o.all ? TERMINAL_LINES_ALL : TERMINAL_LINES);
+      return {
+        header: `${external.ref} (external terminal)`,
+        text: await readExternal(external, n),
+        session: { id: null, name: external.ref, project: null },
+        task: null,
+        turns: null,
+        truncated: false,
+      };
+    }
+    throw new ReadError(found.error, found.external ? 404 : 403);
+  }
+  const s: ReadableSession = found.session;
+  const who = { id: s.id, name: s.name, project: s.project_name };
+  const label = `${s.project_name ? `${s.project_name}/` : ""}${s.name}`;
+  const task = taskHeader(s, !!o.all);
+  const note = found.note ? ` (${found.note})` : "";
+
+  if (s.view !== "chat" || hostLink(s.host_id)) {
+    const n =
+      o.lines ?? (o.all || o.grep ? TERMINAL_LINES_ALL : TERMINAL_LINES);
+    return {
+      header: `${label}${note}: ${s.view}, ${stateOf(s)}`,
+      text: await readResolved(s, n, o.grep),
+      session: who,
+      task,
+      turns: null,
+      truncated: false,
+    };
+  }
+
+  const { turns, total } = chatTurns(s, o);
+  const r: Rendered = o.grep
+    ? grepTurns(turns, o.grep, { all: o.all })
+    : renderTurns(turns, o);
+  const taskText = task
+    ? `Task brief:\n${task.prompt}${task.plan ? `\nPlan: ${task.plan}` : ""}\n\n`
+    : "";
+  const body = r.text
+    ? r.text
+    : o.grep
+      ? `no turns match "${o.grep}"`
+      : "(no messages yet)";
+  const range = r.to
+    ? `turns ${r.from === r.to ? r.to : `${r.from}-${r.to}`} of ${total}`
+    : `${total} turns`;
+  const more =
+    r.truncated && !o.all ? "; more with --turns N, --grep or --all" : "";
+  return {
+    header: `${label}${note} (chat, ${stateOf(s)}), ${o.grep ? `matches for "${o.grep}", ` : ""}${range}${more}`,
+    text: untrusted(s.name, `${taskText}${body}`),
+    session: who,
+    task,
+    turns: { from: r.from, to: r.to, total },
+    truncated: r.truncated,
+  };
+}

package/lib/chat/worker/host.ts

@@ -596,7 +596,9 @@ export class ChatHost {
     if (/^\/compact\b/.test(m.text.trimStart())) this.setCompacting(true);
     const checkpoint = now
       ? this.conversation.send(text, m.images, { now, files: m.files })
-      : this.conversation.send(text, m.images, { files: m.files });
+      : m.files?.length
+        ? this.conversation.send(text, m.images, { files: m.files })
+        : this.conversation.send(text, m.images);
     const user: ChatItem = {
       id: m.id,
       kind: "user",

package/lib/db/migrations/20261019T1500_conversation_search.ts

@@ -0,0 +1,12 @@
+import type { Migration } from "../migration-types";
+import { createConversationSearch } from "../../search/conversations/schema";
+
+export default {
+  key: "20261019T1500_conversation_search",
+  up: (db) => {
+    // The index and the triggers that keep it current. Existing chats are
+    // indexed in the background after startup (lib/search/conversations/backfill.ts),
+    // never in this migration, so a big database doesn't hold up the boot.
+    createConversationSearch(db);
+  },
+} satisfies Migration;

package/lib/demo-reseed.ts

@@ -57,6 +57,10 @@ export function restoreDemo(db: Database.Database, file: string): void {
     db.transaction(() => {
       for (const { name } of tables) {
         if (KEEP_TABLES.has(name)) continue;
+        // The search index (an FTS table, its shadow tables, its keys) is
+        // kept up to date by triggers on chat_items; copying it would
+        // fight them, and shadow tables can't be written at all.
+        if (name.startsWith("chat_search")) continue;
         // Stored columns only: a generated one can't be written.
         const cols = (
           db.prepare(`SELECT * FROM pragma_table_xinfo(?)`).all(name) as {

package/lib/health/facts.ts

@@ -76,7 +76,12 @@ function queue(): QueueFact[] {
 
 // Background jobs still running in a chat whose agent is alive, that have
 // been going long enough to be worth a look at their output.
-function backgroundJobs(now: number, c: HealthConfig): BgFact[] {
+export interface BgTask extends BgFact {
+  outputFile?: string;
+  taskType?: string;
+}
+
+export function runningBgTasks(now: number, minAgeMs: number): BgTask[] {
   const live = new Set(runningWorkers());
   if (!live.size) return [];
   const sessions = db
@@ -86,12 +91,12 @@ function backgroundJobs(now: number, c: HealthConfig): BgFact[] {
        WHERE s.archived_at IS NULL AND s.view = 'chat'`
     )
     .all() as { id: string; name: string; workspace_id: string | null }[];
-  const out: BgFact[] = [];
+  const out: BgTask[] = [];
   for (const s of sessions) {
     if (!live.has(s.id)) continue;
     for (const t of itemsOfKind(s.id, "task")) {
       if (t.status !== "running" || t.ambient) continue;
-      if (now - t.createdAt < c.bgQuietMinutes * MIN) continue;
+      if (now - t.createdAt < minAgeMs) continue;
       const tail = taskOutputTail(t.taskId, t.outputFile);
       out.push({
         sessionId: s.id,
@@ -101,12 +106,17 @@ function backgroundJobs(now: number, c: HealthConfig): BgFact[] {
         description: t.description,
         startedAt: t.createdAt,
         outputAt: tail?.updatedAt ?? null,
+        outputFile: t.outputFile,
+        taskType: t.taskType,
       });
     }
   }
   return out;
 }
 
+const backgroundJobs = (now: number, c: HealthConfig): BgFact[] =>
+  runningBgTasks(now, c.bgQuietMinutes * MIN);
+
 // Every running background job, for the heartbeat a restart reads back.
 export function liveBackgroundJobs(): string[] {
   const live = new Set(runningWorkers());

package/lib/health/spin-tick.ts

@@ -0,0 +1,293 @@
+/**
+ * The I/O half of bg-spin (spin.ts decides): once a minute, for each old
+ * enough background job of a live chat, find its process tree, sample the CPU
+ * of its shells, and stop a job that spins. A stop is by PID, the job's own
+ * tree only: SIGTERM, then SIGKILL for what is still the same process after a
+ * grace. Never a pattern, never a group, never AgentOS, tmux or the agent.
+ * With no old background job there is no process I/O at all.
+ */
+
+import { execFile } from "child_process";
+import fs from "fs";
+import { sendMessage } from "../bus";
+import { findOutputFile } from "../chat/task-output";
+import { queueEventOnce } from "../orchestrator/events";
+import { untrusted } from "../orchestrator/untrusted";
+import { processTable, type ProcRow } from "../process-table";
+import { runningBgTasks, type BgTask } from "./facts";
+import { close, recordTrips } from "./store";
+import {
+  KILL_GRACE_MS,
+  SPIN_KEEP_MS,
+  SPIN_MIN_AGE_MS,
+  baseOf,
+  classifySpin,
+  jobTree,
+  killPlan,
+  parseCpuTime,
+  pickRoot,
+  safeToKill,
+  shellPids,
+  spinEventLine,
+  spinNote,
+  type SpinSample,
+} from "./spin";
+import type { Trip } from "./types";
+
+export interface SpinDeps {
+  tasks: (now: number) => BgTask[];
+  // Output file -> the PIDs holding it open.
+  holders: (files: string[]) => Promise<Map<string, number[]>>;
+  table: () => Promise<ProcRow[] | null>;
+  cpuSeconds: (pids: number[]) => Promise<Map<number, number>>;
+  kill: (pid: number, signal: "SIGTERM" | "SIGKILL") => void;
+  sleep: (ms: number) => Promise<void>;
+  tell: (sessionId: string, body: string) => Promise<void>;
+  event: (
+    workspaceId: string,
+    key: string,
+    subject: string,
+    line: string,
+    now: number
+  ) => void;
+  record: (trip: Trip, now: number) => void;
+}
+
+const run = (cmd: string, args: string[]): Promise<string> =>
+  new Promise((resolve) =>
+    execFile(cmd, args, { timeout: 5000, maxBuffer: 4 << 20 }, (_err, out) =>
+      resolve(out ?? "")
+    )
+  );
+
+// `lsof -F pn`: a `p<pid>` line, then `n<name>` for each file it holds.
+export function parseHolders(out: string): Map<string, number[]> {
+  const map = new Map<string, number[]>();
+  let pid = 0;
+  for (const line of out.split("\n")) {
+    if (line.startsWith("p")) pid = Number(line.slice(1)) || 0;
+    else if (line.startsWith("n") && pid) {
+      const list = map.get(line.slice(1)) ?? [];
+      if (!list.includes(pid)) list.push(pid);
+      map.set(line.slice(1), list);
+    }
+  }
+  return map;
+}
+
+// Linux counts reaped children in /proc; macOS ps's TIME already includes them.
+function procCpu(pid: number): number | null {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+    const f = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+    return (
+      (Number(f[11]) + Number(f[12]) + Number(f[13]) + Number(f[14])) / 100
+    );
+  } catch {
+    return null;
+  }
+}
+
+async function cpuSeconds(pids: number[]): Promise<Map<number, number>> {
+  const out = new Map<number, number>();
+  if (!pids.length) return out;
+  if (process.platform === "linux") {
+    for (const pid of pids) {
+      const sec = procCpu(pid);
+      if (sec !== null) out.set(pid, sec);
+    }
+    return out;
+  }
+  const text = await run("ps", ["-o", "pid=,time=", "-p", pids.join(",")]);
+  for (const line of text.split("\n")) {
+    const m = /^\s*(\d+)\s+(\S+)\s*$/.exec(line);
+    const sec = m ? parseCpuTime(m[2]) : null;
+    if (m && sec !== null) out.set(Number(m[1]), sec);
+  }
+  return out;
+}
+
+export const realSpin: SpinDeps = {
+  tasks: (now) =>
+    runningBgTasks(now, SPIN_MIN_AGE_MS).map((t) => ({
+      ...t,
+      outputFile: t.outputFile ?? findOutputFile(t.taskId) ?? undefined,
+    })),
+  holders: async (files) =>
+    parseHolders(await run("lsof", ["-F", "pn", "--", ...files])),
+  table: () => processTable(0),
+  cpuSeconds,
+  kill: (pid, signal) => process.kill(pid, signal),
+  sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+  tell: async (sessionId, body) => {
+    await sendMessage({
+      fromId: null,
+      to: sessionId,
+      body,
+      fromLabel: "AgentOS health",
+      origin: { kind: "system", label: "Health", body },
+    });
+  },
+  event: (ws, key, subject, line, now) => {
+    queueEventOnce(ws, key, subject, line, now);
+  },
+  record: (trip, now) => {
+    const { opened } = recordTrips([trip], [], now);
+    // History only: nothing to wake a watcher for.
+    for (const row of opened) close(row.id, "stopped", now);
+  },
+};
+
+interface Track {
+  root: number;
+  comm: string;
+  samples: SpinSample[];
+}
+
+const tracks = new Map<string, Track>();
+let running = false;
+
+export function resetSpin(): void {
+  tracks.clear();
+  running = false;
+}
+
+const keyOf = (t: BgTask) => `${t.sessionId}:${t.taskId}`;
+
+// SIGTERM the whole job, root first; SIGKILL what is still the same process.
+async function stopTree(
+  root: number,
+  table: ProcRow[],
+  deps: SpinDeps
+): Promise<number[]> {
+  const plan = killPlan(root, table);
+  const comm = new Map(table.map((r) => [r.pid, r.comm]));
+  const signal = (pid: number, sig: "SIGTERM" | "SIGKILL") => {
+    try {
+      deps.kill(pid, sig);
+    } catch {
+      // Already gone.
+    }
+  };
+  for (const pid of plan) signal(pid, "SIGTERM");
+  await deps.sleep(KILL_GRACE_MS);
+  const after = new Map((await deps.table())?.map((r) => [r.pid, r.comm]));
+  for (const pid of plan)
+    if (after.has(pid) && after.get(pid) === comm.get(pid))
+      signal(pid, "SIGKILL");
+  return plan;
+}
+
+async function sampleAll(
+  jobs: BgTask[],
+  now: number,
+  deps: SpinDeps
+): Promise<{ job: BgTask; track: Track; table: ProcRow[] }[]> {
+  const table = await deps.table();
+  if (!table) return [];
+  const need = jobs.filter((j) => !tracks.get(keyOf(j)) && j.outputFile);
+  if (need.length) {
+    const held = await deps.holders(need.map((j) => j.outputFile as string));
+    for (const j of need) {
+      const root = pickRoot(held.get(j.outputFile as string) ?? [], table);
+      const row = table.find((r) => r.pid === root);
+      if (row)
+        tracks.set(keyOf(j), { root: row.pid, comm: row.comm, samples: [] });
+    }
+  }
+  const live: { job: BgTask; track: Track; table: ProcRow[] }[] = [];
+  for (const j of jobs) {
+    const track = tracks.get(keyOf(j));
+    if (!track) continue;
+    const row = table.find((r) => r.pid === track.root);
+    // Gone, or the PID is someone else's now.
+    if (!row || row.comm !== track.comm) {
+      tracks.delete(keyOf(j));
+      continue;
+    }
+    live.push({ job: j, track, table });
+  }
+  const pids = live.flatMap((l) => shellPids(jobTree(l.track.root, table)));
+  const cpu = await deps.cpuSeconds(pids);
+  for (const { job, track } of live) {
+    const sec = shellPids(jobTree(track.root, table)).reduce(
+      (sum, pid) => sum + (cpu.get(pid) ?? 0),
+      0
+    );
+    track.samples.push({ at: now, cpuSec: sec, outputAt: job.outputAt });
+    track.samples = track.samples.filter((s) => now - s.at <= SPIN_KEEP_MS);
+  }
+  return live;
+}
+
+export async function spinTick(
+  now = Date.now(),
+  deps: SpinDeps = realSpin
+): Promise<void> {
+  if (running) return;
+  running = true;
+  try {
+    // Shell jobs only: a subagent task has no shell to spin.
+    const jobs = deps
+      .tasks(now)
+      .filter((t) => !t.taskType || t.taskType === "local_bash");
+    const names = new Set(jobs.map(keyOf));
+    for (const k of tracks.keys()) if (!names.has(k)) tracks.delete(k);
+    if (!jobs.length) return;
+    for (const { job, track, table } of await sampleAll(jobs, now, deps)) {
+      if (classifySpin(track.samples) !== "spinning") continue;
+      if (!safeToKill(track.root, table)) {
+        console.warn(
+          `[health] bg-spin: not stopping pid ${track.root} (${baseOf(track.comm)}) in ${job.sessionName}: it is not a plain job of the agent`
+        );
+        continue;
+      }
+      const pids = await stopTree(track.root, table, deps);
+      tracks.delete(keyOf(job));
+      console.warn(
+        `[health] bg-spin: stopped "${job.description}" in ${job.sessionName} (session ${job.sessionId}): pid ${track.root}, tree ${pids.join(",")}`
+      );
+      await announce(job, track.root, now, deps);
+    }
+  } finally {
+    running = false;
+  }
+}
+
+async function announce(
+  job: BgTask,
+  pid: number,
+  now: number,
+  deps: SpinDeps
+): Promise<void> {
+  const line = spinEventLine(job.sessionName, job.description, pid);
+  try {
+    deps.record(
+      {
+        check: "bg-spin",
+        subject: keyOf(job),
+        severity: "high",
+        line,
+        detail: { sessionId: job.sessionId, taskId: job.taskId, pid },
+        workspaceId: job.workspaceId,
+      },
+      now
+    );
+  } catch (error) {
+    console.error("[health] bg-spin record:", error);
+  }
+  if (job.workspaceId)
+    deps.event(
+      job.workspaceId,
+      `bg-spin:${keyOf(job)}`,
+      job.sessionId,
+      // The description is the agent's own text.
+      `Health (tasks): ${untrusted("health detector", line)}`,
+      now
+    );
+  try {
+    await deps.tell(job.sessionId, spinNote(job.description, pid));
+  } catch (error) {
+    console.error("[health] bg-spin note:", error);
+  }
+}