@saadnvd1/agent-os 0.3.571 → 0.3.573

package/components/SessionList/useShelfActions.ts

@@ -1,16 +1,25 @@
 import { toast } from "sonner";
 import type { Session } from "@/lib/db";
-import { useSettleSession, useSnoozeSession } from "@/data/sessions/shelf";
 import {
+  usePauseSession,
+  useResumeSession,
+  useSettleSession,
+  useSnoozeSession,
+} from "@/data/sessions/shelf";
+import {
+  pauseUntil,
   snoozePreset,
   wakeLabel,
+  type PausePreset,
   type SnoozePreset,
 } from "@/lib/sidebar/snooze";
 
-// A row menu's Snooze, Unsnooze, Mark done and Reopen, each with an Undo.
+// A row menu's Snooze, Unsnooze, Pause, Resume, Mark done and Reopen.
 export function useShelfActions() {
   const snooze = useSnoozeSession();
   const settle = useSettleSession();
+  const pause = usePauseSession();
+  const resume = useResumeSession();
   const unsnooze = (session: Session) =>
     snooze.mutate({ id: session.id, until: null });
   return {
@@ -28,6 +37,34 @@ export function useShelfActions() {
       );
     },
     unsnooze,
+    // Stops its agent at the end of the step (or now) and starts it again at
+    // the time. A refusal (it is waiting on you, merging) is the toast.
+    pause: (session: Session, preset: PausePreset, now = false) => {
+      const until = pauseUntil(preset);
+      pause.mutate(
+        { id: session.id, until, mode: now ? "now" : "turn" },
+        {
+          onSuccess: () =>
+            toast.success(
+              until
+                ? `Pausing until ${wakeLabel(until.getTime())}`
+                : "Pausing until you resume",
+              {
+                action: {
+                  label: "Keep running",
+                  onClick: () => resume.mutate({ id: session.id }),
+                },
+              }
+            ),
+          onError: (e) => toast.error(e.message),
+        }
+      );
+    },
+    resume: (session: Session) =>
+      resume.mutate(
+        { id: session.id },
+        { onError: (e) => toast.error(e.message) }
+      ),
     settle: (session: Session) =>
       settle.mutate(
         { id: session.id, settled: true },

package/data/sessions/shelf.ts

@@ -83,3 +83,53 @@ export function useSettleSession() {
         : { settled_at: null, active_at: now }
   );
 }
+
+async function send(method: string, url: string, body?: object) {
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok)
+    throw new Error(
+      (await res.json().catch(() => null))?.error ?? "Request failed"
+    );
+}
+
+// until null: until resumed. The row moves to "pausing" at once; the server
+// stops the agent at the end of its step (or now) and the push settles it.
+export function usePauseSession() {
+  return useShelfMutation<{
+    id: string;
+    until: Date | null;
+    mode: "turn" | "now";
+  }>(
+    ({ id, until, mode }) =>
+      send("POST", `/api/sessions/${id}/pause`, {
+        until: until?.toISOString() ?? null,
+        mode,
+      }),
+    ({ until }) => ({
+      pause_state: "pausing",
+      paused_until: until ? toSqliteTime(until) : null,
+    })
+  );
+}
+
+// Resume now, or keep running while it is still pausing.
+export function useResumeSession() {
+  return useShelfMutation<{ id: string }>(
+    ({ id }) => send("DELETE", `/api/sessions/${id}/pause`),
+    () => ({ pause_state: "resuming", paused_until: null })
+  );
+}
+
+export function useChangeResumeTime() {
+  return useShelfMutation<{ id: string; until: Date | null }>(
+    ({ id, until }) =>
+      send("PATCH", `/api/sessions/${id}/pause`, {
+        until: until?.toISOString() ?? null,
+      }),
+    ({ until }) => ({ paused_until: until ? toSqliteTime(until) : null })
+  );
+}

package/data/tasks/index.ts

@@ -1,6 +1,7 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import type { TaskView } from "@/lib/tasks";
 import type { QueuedTaskView } from "@/lib/tasks/queue";
+import type { Priority } from "@/lib/tasks/schedule-types";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "./keys";
 import { usePollWhenOffline } from "../push/connection";
@@ -43,6 +44,7 @@ export function useCreateTask() {
       projectId: string;
       prompt: string;
       model?: string;
+      priority?: Priority;
       baseBranch?: string;
       hostId?: string;
       view?: "chat" | "terminal";

package/data/tasks/queue.ts

@@ -1,6 +1,11 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { QueuedTaskView, StartOutcome } from "@/lib/tasks/queue";
-import { queueRequest, type QueueMenuAction } from "@/lib/sidebar/queued";
+import {
+  priorityRequest,
+  queueRequest,
+  type QueueMenuAction,
+} from "@/lib/sidebar/queued";
+import type { Priority } from "@/lib/tasks/schedule-types";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "./keys";
 import { usePollWhenOffline } from "../push/connection";
@@ -40,3 +45,35 @@ export function useQueueAction() {
     },
   });
 }
+
+// Changes where a waiting task stands; the line re-ranks from the push.
+export function useSetPriority() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      id,
+      priority,
+    }: {
+      id: string;
+      priority: Priority;
+    }) => {
+      const { url, init } = priorityRequest(id, priority);
+      return json<unknown>(await fetch(url, init));
+    },
+    onMutate: async ({ id, priority }) => {
+      await queryClient.cancelQueries({ queryKey: taskKeys.queue() });
+      const previous = queryClient.getQueryData<QueuedTaskView[]>(
+        taskKeys.queue()
+      );
+      queryClient.setQueryData<QueuedTaskView[]>(taskKeys.queue(), (old) =>
+        old?.map((q) => (q.id === id ? { ...q, priority } : q))
+      );
+      return { previous };
+    },
+    onError: (_e, _v, context) => {
+      if (context?.previous)
+        queryClient.setQueryData(taskKeys.queue(), context.previous);
+    },
+    onSettled: () => queryClient.invalidateQueries({ queryKey: taskKeys.all }),
+  });
+}

package/lib/bus/index.ts

@@ -15,6 +15,7 @@ import { deliverToPane, type Delivery } from "./delivery";
 import { resolveRef, wasNames, type Candidate } from "./resolve";
 import { tmuxPane } from "./tmux-pane";
 import { hostLink } from "../hosts/remote-api";
+import { pauseHoldOf, pausedNote } from "../tasks/pause-hold";
 import { relayToHeldTask } from "../tasks/held-remote";
 import { heldOrchestrator, heldTarget } from "./held-reply";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
@@ -215,6 +216,16 @@ export async function deliver(
       return { state: "failed", why };
     }
   }
+  // A paused terminal has no agent: the message waits for the resume prompt.
+  const paused = pauseHoldOf(to.id);
+  if (paused) {
+    if (from.messageId)
+      db.prepare(`UPDATE bus_messages SET held_pause_id = ? WHERE id = ?`).run(
+        paused.pauseId,
+        from.messageId
+      );
+    return { state: "queued" };
+  }
   if (!statusDetector.sessionExists(to.tmux_name))
     return { state: "failed", why: "its terminal isn't running" };
   try {
@@ -298,7 +309,10 @@ export async function sendMessage(opts: {
         : opts.origin,
     }
   );
-  if (delivery.state !== "failed") {
+  // A message held for a paused terminal isn't delivered until it resumes.
+  const hold = pauseHoldOf(to.id);
+  const parked = !!hold && to.view !== "chat";
+  if (delivery.state !== "failed" && !parked) {
     db.prepare(
       `UPDATE bus_messages SET delivered_at = datetime('now') WHERE id = ?`
     ).run(id);
@@ -308,7 +322,12 @@ export async function sendMessage(opts: {
       `UPDATE bus_messages SET read_at = datetime('now') WHERE id = ?`
     ).run(id);
   const message = toView(db.prepare(`${SELECT} WHERE m.id = ?`).get(id) as Row);
-  return { message, delivery, note };
+  const heldNote = hold ? pausedNote(to.name, hold) : null;
+  return {
+    message,
+    delivery,
+    note: [note, heldNote].filter(Boolean).join("; ") || undefined,
+  };
 }
 
 function storeForHolder(

package/lib/chat/hold.ts

@@ -1,7 +1,8 @@
 /**
  * Holding a chat still while something outside it works on its task: a
  * move to another machine (its row is 'moving'), or a Land of the stack it
- * sits in (the stack is 'landing'). Both are facts in SQLite, so the worker
+ * sits in (the stack is 'landing'), or a timed pause (lib/tasks/pause.ts).
+ * All are facts in SQLite, so the worker
  * process sees the hold too: it neither starts what's queued (queued.ts) nor
  * a turn for a message sent meanwhile, which waits in the queue instead.
  *
@@ -17,6 +18,8 @@ export const HELD_SQL = `(
   EXISTS (SELECT 1 FROM sessions WHERE id = @sid AND task_status = 'moving')
   OR EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
              WHERE i.session_id = @sid AND s.status = 'landing')
+  OR EXISTS (SELECT 1 FROM sessions WHERE id = @sid
+             AND pause_state IN ('pausing', 'paused'))
 )`;
 
 export const isHeld = (sessionId: string): boolean =>
@@ -45,12 +48,14 @@ interface HoldRow {
   moved_to: string | null;
   quick_of: string | null;
   landing: number;
+  pause_state: string | null;
+  paused_until: string | null;
 }
 
 const holdRow = (sessionId: string) =>
   db
     .prepare(
-      `SELECT task_status, moved_to, quick_of,
+      `SELECT task_status, moved_to, quick_of, pause_state, paused_until,
          EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
                  WHERE i.session_id = @sid AND s.status = 'landing') AS landing
        FROM sessions WHERE id = @sid`
@@ -63,6 +68,10 @@ export function chatHold(sessionId: string): string | null {
   if (row?.task_status === "moving" && collecting.has(sessionId))
     return "It's sent once the move to another machine finishes";
   if (row?.landing) return "It's sent once its stack has landed";
+  if (row?.pause_state === "pausing" || row?.pause_state === "paused")
+    return row.paused_until
+      ? "It's sent when the session resumes, with anything else held meanwhile"
+      : "It's sent when the session is resumed, with anything else held meanwhile";
   return null;
 }
 

package/lib/db/migrations.ts

@@ -14,7 +14,7 @@ import { moveSchedulesToRecipes } from "./schedules-move";
 // integer `id`: `key: "YYYYMMDDTHHMM_snake_name"` (UTC, e.g.
 // "20261014T0130_share_links"). Hand-picked numbers collide when two tasks run
 // in parallel and the loser is silently skipped on databases that already
-// applied the winner. Ids 1..88 are legacy: they run first, by number, and
+// applied the winner. Ids 1..89 are legacy: they run first, by number, and
 // never change. Timestamp keys run after them, in lexical order. Never edit a
 // migration that has shipped; add a new one. lib/db/migrations.test.ts
 // enforces all of this.
@@ -2187,6 +2187,61 @@ export const migrations: Migration[] = [
       );
     },
   },
+  {
+    key: "20261014T0900_task_scheduling",
+    up: (db) => {
+      // Priority, "after any" consumption, and timed pause. Additive: every
+      // existing row reads as normal priority and not paused.
+      const has = (table: string, col: string) =>
+        (
+          db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]
+        ).some((c) => c.name === col);
+      const add = (table: string, col: string, def: string) => {
+        if (!has(table, col))
+          db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def}`);
+      };
+      add("task_queue", "priority", "TEXT NOT NULL DEFAULT 'normal'");
+      add("task_queue", "machine_needs", "TEXT");
+      add("task_queue", "after_any_used", "TEXT");
+      add("task_queue", "wait_code", "TEXT");
+      db.exec(
+        `CREATE UNIQUE INDEX IF NOT EXISTS idx_task_queue_after_any_used
+           ON task_queue(after_any_used) WHERE after_any_used IS NOT NULL`
+      );
+      add("sessions", "priority", "TEXT");
+      add("sessions", "pause_state", "TEXT");
+      add("sessions", "paused_until", "TEXT");
+      add("sessions", "pause_id", "INTEGER");
+      // "Started on <machine> · <why>" for a task the scheduler placed.
+      add("sessions", "placed_note", "TEXT");
+      add("bus_messages", "held_pause_id", "INTEGER");
+      add("projects", "machine_needs", "TEXT");
+      add("projects", "machine_needs_source", "TEXT");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS task_pauses (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          mode TEXT NOT NULL DEFAULT 'turn',
+          by_kind TEXT NOT NULL DEFAULT 'person',
+          by_id TEXT,
+          reason TEXT,
+          until_at TEXT,
+          state TEXT NOT NULL DEFAULT 'pausing',
+          requested_at TEXT NOT NULL DEFAULT (datetime('now')),
+          paused_at TEXT,
+          resume_requested_at TEXT,
+          resume_by_kind TEXT,
+          resumed_at TEXT,
+          ended_at TEXT,
+          end_reason TEXT,
+          interrupted INTEGER NOT NULL DEFAULT 0,
+          held_count INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_task_pauses_session
+          ON task_pauses(session_id, state);
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this legacy id or timestamp key, inclusive (tests that

package/lib/db/types.ts

@@ -86,6 +86,13 @@ export interface Session {
   // Snoozed until this time, from snoozed_at; activity since wakes it early.
   snoozed_until?: string | null;
   snoozed_at?: string | null;
+  // Task priority (null reads as normal) and timed pause (lib/tasks/pause.ts):
+  // pausing, paused or resuming, until when (null: until resumed).
+  priority?: string | null;
+  pause_state?: "pausing" | "paused" | "resuming" | null;
+  paused_until?: string | null;
+  pause_id?: number | null;
+  placed_note?: string | null;
   // Set by done: hidden from the sidebar and the orchestrator, never deleted.
   archived_at: string | null;
   // On the sidebar's Pinned shelf (0/1 from SQLite).
@@ -172,10 +179,33 @@ export interface Project {
   lh_board_id: string | null;
   lh_board_name: string | null;
   lh_board_page_id: string | null;
+  // What its tasks need from a machine (JSON array), and where that came from.
+  machine_needs?: string | null;
+  machine_needs_source?: string | null;
   created_at: string;
   updated_at: string;
 }
 
+export interface TaskPause {
+  id: number;
+  session_id: string;
+  mode: "turn" | "now";
+  by_kind: "person" | "orchestrator" | "scheduler";
+  by_id: string | null;
+  reason: string | null;
+  until_at: string | null;
+  state: "pausing" | "paused" | "resuming" | "ended";
+  requested_at: string;
+  paused_at: string | null;
+  resume_requested_at: string | null;
+  resume_by_kind: string | null;
+  resumed_at: string | null;
+  ended_at: string | null;
+  end_reason: "resumed" | "cancelled" | "finished" | "failed" | null;
+  interrupted: number;
+  held_count: number;
+}
+
 export interface ProjectDevServer {
   id: string;
   project_id: string;

package/lib/done/index.ts

@@ -8,6 +8,7 @@
  * its own action, archive.ts). What it will do is decided first (plan.ts).
  */
 
+import { endPauseOnFinish } from "../tasks/pause-hold";
 import { db, queries, type Session } from "../db";
 import { endSessionAgent } from "../sessions/end";
 import { clearQueue } from "../chat/queued";
@@ -112,6 +113,7 @@ function mark(s: Session, status: "merged" | "done", pr: TaskPR | null) {
       ? `UPDATE sessions SET task_status = 'merged', pr_status = 'merged' WHERE id = ?`
       : `UPDATE sessions SET task_status = 'done' WHERE id = ?`
   ).run(s.id);
+  endPauseOnFinish(s.id);
   syncTaskCardInBackground(s, status, pr);
   void sessionEnded(s.id, status);
   if (status === "merged") {

package/lib/drafts.ts

@@ -4,6 +4,7 @@
  */
 
 import type { AgentType } from "./providers";
+import type { Priority } from "@/lib/tasks/schedule-types";
 import type { ChatAccess } from "./chat/events";
 import { resolveModelForAgent } from "./model-catalog";
 import { projectsInWorkspace } from "./sidebar/shelves";
@@ -26,6 +27,8 @@ export interface Draft {
   // A task's own model, "provider/model"; unset, its roles' models
   // (lib/models).
   taskModel?: string | null;
+  // A task's priority in the queue; unset: normal.
+  taskPriority?: Priority;
   createdAt: number;
 }
 

package/lib/hosts/peer-load.ts

@@ -0,0 +1,120 @@
+/**
+ * How loaded each linked machine is, for placing tasks. The placing server
+ * polls a peer's GET /api/load every PEER_POLL_MS, only while a task is
+ * waiting that could go there. A reading older than PEER_STALE_MS counts as
+ * red, so nothing is placed on a machine that can't be seen.
+ */
+
+import { getHost } from "./index";
+import { hostApi, hostLink, linkedHostIds } from "./remote-api";
+import { feedGate } from "../load/start-gate";
+import type { MachineSource } from "../load/machines";
+import type { LoadLevel } from "../load/level";
+
+export const PEER_POLL_MS = 15_000;
+export const PEER_STALE_MS = 60_000;
+
+export interface PeerReading {
+  at: number;
+  level: LoadLevel;
+  load1: number;
+  cores: number;
+  memUsedPct: number;
+  booted: number;
+  capabilities: string[];
+}
+
+const g = globalThis as unknown as {
+  __agentosPeerLoad?: Map<string, PeerReading>;
+  __agentosPeerPolling?: Map<string, Promise<void>>;
+};
+const readings = (g.__agentosPeerLoad ??= new Map<string, PeerReading>());
+const polling = (g.__agentosPeerPolling ??= new Map<string, Promise<void>>());
+
+const LEVELS = ["green", "amber", "red"];
+const num = (v: unknown, max = 1e6) =>
+  typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= max ? v : null;
+
+// Another machine's answer is data, not trust: anything off is no reading.
+export function parseReading(body: unknown, at: number): PeerReading | null {
+  if (!body || typeof body !== "object") return null;
+  const b = body as Record<string, unknown>;
+  const level = b.level;
+  const load1 = num(b.load1);
+  const cores = num(b.cores, 4096);
+  if (typeof level !== "string" || !LEVELS.includes(level)) return null;
+  if (load1 === null || !cores) return null;
+  const caps = Array.isArray(b.capabilities)
+    ? b.capabilities
+        .filter((c): c is string => typeof c === "string" && c.length <= 24)
+        .slice(0, 12)
+    : [];
+  return {
+    at,
+    level: level as LoadLevel,
+    load1,
+    cores,
+    memUsedPct: num(b.memUsedPct, 100) ?? 0,
+    booted: num(b.booted, 1000) ?? 0,
+    capabilities: caps,
+  };
+}
+
+export type LoadFetch = (hostId: string) => Promise<unknown>;
+
+const fetchLoad: LoadFetch = async (hostId) => {
+  const link = hostLink(hostId);
+  if (!link) throw new Error("not linked");
+  return hostApi<unknown>(link, "/api/load", { timeout: 5000 });
+};
+
+// Reads every linked machine whose last reading is older than the poll time.
+// A failure keeps the old reading, which then ages into stale.
+export async function refreshPeers(
+  hostIds: Iterable<string> = linkedHostIds(),
+  now = Date.now(),
+  fetcher: LoadFetch = fetchLoad
+): Promise<void> {
+  await Promise.all(
+    [...hostIds].map((hostId) => {
+      const last = readings.get(hostId);
+      if (last && now - last.at < PEER_POLL_MS) return;
+      const running = polling.get(hostId);
+      if (running) return running;
+      const p = fetcher(hostId)
+        .then((body) => {
+          const r = parseReading(body, now);
+          if (!r) return;
+          readings.set(hostId, r);
+          feedGate(hostId, r.level, now);
+        })
+        .catch(() => undefined)
+        .finally(() => polling.delete(hostId));
+      polling.set(hostId, p);
+      return p;
+    })
+  );
+}
+
+export function setPeerReading(hostId: string, r: PeerReading | null): void {
+  if (r) readings.set(hostId, r);
+  else readings.delete(hostId);
+}
+
+export function peerReading(hostId: string): PeerReading | null {
+  return readings.get(hostId) ?? null;
+}
+
+export function peerSource(hostId: string, now: number): MachineSource {
+  const r = readings.get(hostId);
+  const stale = !r || now - r.at > PEER_STALE_MS;
+  return {
+    hostId,
+    label: getHost(hostId)?.name ?? "that machine",
+    level: r?.level ?? null,
+    booted: r?.booted ?? 0,
+    maxBooted: 2,
+    capabilities: r?.capabilities ?? [],
+    stale,
+  };
+}

package/lib/load/machines.ts

@@ -0,0 +1,124 @@
+/**
+ * What the scheduler knows about a machine when it decides to start a task
+ * there: how loaded it is (sampled by the monitor every 10s, or polled from a
+ * linked machine every 15s), whether it has been calm long enough, how many
+ * simulators are booted, and when it last started something. Nothing here
+ * samples anything itself: the load is the thing being protected.
+ */
+
+import os from "os";
+import { bootedCount, maxBooted } from "../simulator/lease";
+import { simulatorAvailable } from "../simulator/available";
+import { currentLevel, loadEnabled } from "./monitor";
+import type { LoadLevel } from "./level";
+import type { MachineLevel, MachineView } from "../tasks/schedule";
+import { HEAVY_BOOT_MS, LOCAL, gateOf, startsBy } from "./start-gate";
+
+export {
+  HEAVY_BOOT_MS,
+  LOCAL,
+  StartGate,
+  feedGate,
+  recordAutoStart,
+  resetMachineStarts,
+} from "./start-gate";
+
+// Development only: pin the level so the holds can be shown without loading
+// the machine.
+function overrideLevel(): MachineLevel | null {
+  if (process.env.NODE_ENV !== "development") return null;
+  const v = process.env.AGENTOS_LOAD_LEVEL;
+  return v === "red" || v === "amber" || v === "green" ? v : null;
+}
+
+export interface LocalFacts {
+  level: LoadLevel | null;
+  load1: number;
+  cores: number;
+  memUsedPct: number;
+  booted: number;
+  capabilities: string[];
+}
+
+// What this machine can run. Only a Mac with Xcode's tools gives a simulator.
+export function machineCapabilities(): string[] {
+  if (process.platform !== "darwin") return [process.platform];
+  return simulatorAvailable() ? ["mac", "xcode", "simulator"] : ["mac"];
+}
+
+export function localFacts(): LocalFacts {
+  const cores = os.cpus().length || 1;
+  const total = os.totalmem();
+  return {
+    level: overrideLevel() ?? currentLevel(),
+    load1: Math.round(os.loadavg()[0] * 10) / 10,
+    cores,
+    memUsedPct: Math.round(((total - os.freemem()) / total) * 100),
+    booted: bootedCount(),
+    capabilities: machineCapabilities(),
+  };
+}
+
+export interface MachineSource {
+  hostId: string;
+  label: string;
+  level: LoadLevel | null;
+  booted: number;
+  maxBooted: number;
+  capabilities: string[];
+  // A peer whose reading is missing or older than the stale limit.
+  stale?: boolean;
+}
+
+// The scheduler's view of a machine, from its readings and the start
+// bookkeeping. Pure given those.
+export function viewOf(src: MachineSource, now: number): MachineView {
+  const gate = gateOf(src.hostId).view(now, src.level);
+  const s = startsBy.get(src.hostId);
+  const level: MachineLevel = src.stale ? "red" : (src.level ?? "green");
+  return {
+    label: src.label,
+    enabled: src.hostId !== LOCAL || loadEnabled(),
+    reading: src.stale ? false : gate.reading && src.level === null,
+    level,
+    settled: src.stale ? false : gate.settled,
+    settleLeftMs: gate.settleLeftMs,
+    booted: src.booted,
+    maxBooted: src.maxBooted,
+    heavyStarting: (s?.heavy ?? []).filter((t) => now - t < HEAVY_BOOT_MS)
+      .length,
+    lastAutoStartAt: s?.auto ?? null,
+    lastHeavyStartAt: s?.heavy.length ? Math.max(...s.heavy) : null,
+  };
+}
+
+export function localView(now = Date.now()): MachineView {
+  const facts = localFacts();
+  const over = overrideLevel();
+  if (over) {
+    // The pinned level counts as long observed: calm unless red.
+    const view = viewOf(
+      {
+        hostId: LOCAL,
+        label: "this machine",
+        level: over,
+        booted: facts.booted,
+        maxBooted: maxBooted(),
+        capabilities: facts.capabilities,
+      },
+      now
+    );
+    return { ...view, reading: false, settled: over !== "red" };
+  }
+  return viewOf(
+    {
+      hostId: LOCAL,
+      label: "this machine",
+      level: facts.level,
+      booted: facts.booted,
+      maxBooted: maxBooted(),
+      capabilities: facts.capabilities,
+    },
+    now
+  );
+}