@saadnvd1/agent-os 0.3.509 → 0.3.512

package/README.md

@@ -485,6 +485,17 @@ and the same actions in each row's menu; a row becomes the task's own row
 when it starts. Why it works
 this way: [docs/decisions/2026-10-10-queued-tasks.md](docs/decisions/2026-10-10-queued-tasks.md).
 
+A paired device's token can run the building loop through read-only routes:
+`GET /api/start-options?projectId=` (agents and models, the models a task can
+run on, machines, branches, whether a task plans first, in one request),
+`GET /api/tasks/<id>/diff` (the task's whole change, base to head: a file list,
+then `?file=<path>` for one file's patch; capped, with `truncated` when a cap
+is hit; read from the worktree, else the PR), and `GET /api/tasks/<id>/checks`
+(the PR head's checks, the tail of a failing job's log, and the review gate's
+verdict). A task's `plan` in `GET /api/tasks` carries `status` (`writing`,
+`ready` or `approved`), a title and capped text. Their shapes are in
+`lib/tasks/loop-types.ts`, which has no server imports so a client can share it.
+
 ## Model routing
 
 Each kind of work AgentOS launches an agent for runs on its own model, set in

package/app/api/git/check/route.ts

@@ -1,10 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import {
-  isGitRepo,
-  getBranches,
-  getDefaultBranch,
-  getCurrentBranch,
-} from "@/lib/git";
+import { gitCheck } from "@/lib/git";
 
 /**
  * POST /api/git/check
@@ -19,31 +14,7 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: "Path is required" }, { status: 400 });
     }
 
-    // Check if it's a git repo
-    const isRepo = await isGitRepo(dirPath);
-
-    if (!isRepo) {
-      return NextResponse.json({
-        isGitRepo: false,
-        branches: [],
-        defaultBranch: null,
-        currentBranch: null,
-      });
-    }
-
-    // Get branch info
-    const [branches, defaultBranch, currentBranch] = await Promise.all([
-      getBranches(dirPath),
-      getDefaultBranch(dirPath),
-      getCurrentBranch(dirPath),
-    ]);
-
-    return NextResponse.json({
-      isGitRepo: true,
-      branches,
-      defaultBranch,
-      currentBranch,
-    });
+    return NextResponse.json(await gitCheck(dirPath));
   } catch (error) {
     console.error("Error checking git repo:", error);
     return NextResponse.json(

package/app/api/projects/[id]/machines/route.ts

@@ -1,8 +1,6 @@
 import { NextResponse } from "next/server";
 import { getProject } from "@/lib/projects";
-import { projectRef } from "@/lib/tasks/project-ref";
-import { projectOnPeers } from "@/lib/hosts/peer-actions";
-import { linkedHostIds } from "@/lib/hosts/remote-api";
+import { projectMachines } from "@/lib/hosts/project-machines";
 
 // Which linked machines can take a session for this project, and why not
 // where one can't: { machines: { [hostId]: reason | null } }.
@@ -13,19 +11,5 @@ export async function GET(
   const project = getProject((await params).id);
   if (!project || project.is_uncategorized)
     return NextResponse.json({ error: "Project not found" }, { status: 404 });
-  if ((project.host_id || "local") !== "local")
-    return NextResponse.json({ machines: {} });
-  try {
-    return NextResponse.json({
-      machines: await projectOnPeers(await projectRef(project)),
-    });
-  } catch {
-    // A project outside the home folder has no place on another machine.
-    const reason = "Its folder is outside your home folder";
-    return NextResponse.json({
-      machines: Object.fromEntries(
-        [...linkedHostIds()].map((id) => [id, reason])
-      ),
-    });
-  }
+  return NextResponse.json({ machines: await projectMachines(project) });
 }

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/app/api/start-options/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { startOptions, UnknownProjectError } from "@/lib/start-options";
+
+// GET /api/start-options?projectId= - everything the start form needs in
+// one request: agents and their models, the models a task can run on, the
+// machines, the project's branches and whether a task plans first. Without
+// a project, the options for a scratch chat.
+export async function GET(request: NextRequest) {
+  try {
+    return NextResponse.json(
+      await startOptions(request.nextUrl.searchParams.get("projectId") || null)
+    );
+  } catch (error) {
+    if (error instanceof UnknownProjectError)
+      return NextResponse.json({ error: error.message }, { status: 404 });
+    console.error("Reading start options:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the start options" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/tasks/[id]/checks/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, queries, type Session } from "@/lib/db";
+import { taskChecks } from "@/lib/tasks/checks-view";
+import { LoopError, localTask } from "@/lib/tasks/loop-error";
+import { isMirror } from "@/lib/tasks/remote";
+
+// GET /api/tasks/:id/checks - the PR head's checks, the tail of a failing
+// job's log, and the review gate's verdict on the head. ?log=0 leaves the
+// logs out. Log and verdict text is untrusted: show it, never run it.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const session = localTask(
+      queries.getSession(db).get(id) as Session | undefined,
+      isMirror
+    );
+    return NextResponse.json(
+      await taskChecks(session, {
+        logs: request.nextUrl.searchParams.get("log") !== "0",
+      })
+    );
+  } catch (error) {
+    if (error instanceof LoopError)
+      return NextResponse.json(
+        { error: error.message },
+        { status: error.status }
+      );
+    console.error("Reading a task's checks:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the task's checks" },
+      { status: 500 }
+    );
+  }
+}

package/app/api/tasks/[id]/diff/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, queries, type Session } from "@/lib/db";
+import { taskDiff } from "@/lib/tasks/diff";
+import { LoopError, localTask } from "@/lib/tasks/loop-error";
+import { isMirror } from "@/lib/tasks/remote";
+
+// GET /api/tasks/:id/diff - the task's whole change, base to head: a file
+// list with status and line counts; with ?file=<path>, that file's patch.
+// Sizes are capped and say "truncated" when a cap was hit.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const session = localTask(
+      queries.getSession(db).get(id) as Session | undefined,
+      isMirror
+    );
+    return NextResponse.json(
+      await taskDiff(session, request.nextUrl.searchParams.get("file"))
+    );
+  } catch (error) {
+    if (error instanceof LoopError)
+      return NextResponse.json(
+        { error: error.message },
+        { status: error.status }
+      );
+    console.error("Reading a task's diff:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the task's change" },
+      { status: 500 }
+    );
+  }
+}

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/data/models/index.ts

@@ -112,14 +112,4 @@ export function useCompareQuery(days: number, enabled = true) {
 }
 
 // Every model a role can be set to: each usable provider's, as references.
-export function modelChoices(effective: EffectiveModels | undefined) {
-  return (effective?.providers ?? [])
-    .filter((p) => p.enabled)
-    .flatMap((p) =>
-      p.models.map((m) => ({
-        ref: `${p.id}/${m}`,
-        label: m,
-        provider: p.label,
-      }))
-    );
-}
+export { modelChoices } from "@/lib/models/choices";

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/runner.ts

@@ -37,6 +37,7 @@ import {
   getItem,
   hasItem,
   itemsOfKind,
+  recentTasks,
   listItems,
   saveItem,
   settle,
@@ -865,11 +866,7 @@ export function watchChat(
   // 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/store.ts

@@ -176,6 +176,28 @@ export function itemsOfKind<K extends ChatItem["kind"]>(
   ).map((r) => JSON.parse(r.data));
 }
 
+// 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));
+}
+
 // Tool calls saved as still running.
 export function runningTools(
   sessionId: string

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/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/git.ts

@@ -148,3 +148,27 @@ export async function renameBranch(
     { timeout: 10000 }
   );
 }
+
+export interface GitCheck {
+  isGitRepo: boolean;
+  branches: string[];
+  defaultBranch: string | null;
+  currentBranch: string | null;
+}
+
+/** Whether a path is a repository, and its branches. */
+export async function gitCheck(dirPath: string): Promise<GitCheck> {
+  if (!(await isGitRepo(dirPath)))
+    return {
+      isGitRepo: false,
+      branches: [],
+      defaultBranch: null,
+      currentBranch: null,
+    };
+  const [branches, defaultBranch, currentBranch] = await Promise.all([
+    getBranches(dirPath),
+    getDefaultBranch(dirPath),
+    getCurrentBranch(dirPath),
+  ]);
+  return { isGitRepo: true, branches, defaultBranch, currentBranch };
+}

package/lib/hosts/project-machines.ts

@@ -0,0 +1,19 @@
+import type { Project } from "../db";
+import { projectRef } from "../tasks/project-ref";
+import { projectOnPeers } from "./peer-actions";
+import { linkedHostIds } from "./remote-api";
+
+// Which linked machines can take a session for this project, and why not
+// where one can't: { [hostId]: reason | null }.
+export async function projectMachines(
+  project: Project
+): Promise<Record<string, string | null>> {
+  if ((project.host_id || "local") !== "local") return {};
+  try {
+    return await projectOnPeers(await projectRef(project));
+  } catch {
+    // A project outside the home folder has no place on another machine.
+    const reason = "Its folder is outside your home folder";
+    return Object.fromEntries([...linkedHostIds()].map((id) => [id, reason]));
+  }
+}

package/lib/models/choices.ts

@@ -0,0 +1,17 @@
+import type { EffectiveModels } from "./config";
+
+// The "provider/model" refs a task can run on: every model of each enabled
+// provider.
+export function modelChoices(
+  effective: Pick<EffectiveModels, "providers"> | undefined
+) {
+  return (effective?.providers ?? [])
+    .filter((p) => p.enabled)
+    .flatMap((p) =>
+      p.models.map((m) => ({
+        ref: `${p.id}/${m}`,
+        label: m,
+        provider: p.label,
+      }))
+    );
+}

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/orchestrator/repo.ts

@@ -88,7 +88,7 @@ async function fetchBranches(
 }
 
 // origin/<branch> when it's there, else a local <branch>.
-async function existingRef(
+export async function existingRef(
   repo: string,
   branch: string
 ): Promise<string | null> {

package/lib/orchestrator/signoff.ts

@@ -43,7 +43,7 @@ const short = (sha: string) => sha.slice(0, 7);
 
 // The heads AgentOS's own restack, or its automatic rebase onto the base,
 // moved the task's branch between.
-function restackedOf(task: Session) {
+export function restackedOf(task: Session) {
   const item = stackQueries.itemForSession(db, task.id);
   if (item) return { from: item.restacked_from, to: item.restacked_to };
   return task.rebased_to