@saadnvd1/agent-os 0.3.736 → 0.3.738

package/lib/chat/drivers/pi.ts

@@ -7,6 +7,7 @@ import { PiAccess, PiDialogs, writeExtension } from "./pi-approvals";
 import { TEXT_TOOLS_EXTENSION } from "./pi-text-tools";
 import { PiMapper } from "./pi-mapper";
 import { PiRpc } from "./pi-rpc";
+import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
 
 type P = Record<string, unknown>;
 
@@ -17,7 +18,10 @@ export function piArgs(o: ChatStartOptions, ...extensions: string[]): string[] {
   // A path, so a conversation started elsewhere never makes Pi ask about it.
   if (o.resumeId) args.push("--session", o.resumeId);
   if (o.model && o.model !== AGENT_DEFAULT_MODEL) args.push("--model", o.model);
-  if (o.systemAppend) args.push("--append-system-prompt", o.systemAppend);
+  args.push(
+    "--append-system-prompt",
+    [o.systemAppend, RESULTS_BRIEF].filter(Boolean).join("\n\n")
+  );
   return args;
 }
 
@@ -78,6 +82,7 @@ export const piDriver: ChatDriver = {
     const dialogs = new PiDialogs(emit);
     const access = new PiAccess(options.access);
     // Sent now: goes once the stopped run has ended.
+    let nudged = false;
     const held: { text: string; images?: ChatImage[] }[] = [];
     const rpc: PiRpc = new PiRpc(
       piArgs(
@@ -132,6 +137,13 @@ export const piDriver: ChatDriver = {
           if (!s.isCompacting) break;
           await new Promise((r) => setTimeout(r, 200));
         }
+      if (!nudged && mapper.needsSummary()) {
+        nudged = true;
+        console.info("[chat] asked the model for its results summary");
+        void prompt(SUMMARY_NUDGE);
+        return;
+      }
+      nudged = false;
       mapper.endTurn();
       void rpc
         .request<{ contextUsage?: P }>("get_session_stats")

package/lib/chat/drivers/turn-outcome.ts

@@ -106,3 +106,28 @@ export function logTurnEnd(o: {
     })
   );
 }
+
+// Asked of the model once when its turn ran tools but ended without the
+// report it set out to give.
+export const SUMMARY_NUDGE =
+  "You ran checks or tools but haven't reported the results. Reply now with a short summary: what worked, what failed (with the exit code or HTTP status) and what you didn't check. Don't run more tools.";
+
+// Appended to the system prompt of agents AgentOS drives itself.
+export const RESULTS_BRIEF =
+  "After running checks, probes or discovery, end your turn with a results summary: what worked, what failed (exit code or HTTP status) and what you didn't check. Never end on a lead-in such as 'Here's what I found:' without the list.";
+
+// Whether a turn that ran tools ended without telling what they found: an
+// empty last reply, or one that only promises the report.
+export function needsSummary(r: {
+  toolsRun: number;
+  text: string;
+  toolCalls: number;
+  finishReason?: string;
+  error?: string;
+  aborted?: boolean;
+}): boolean {
+  if (r.toolsRun === 0 || r.toolCalls > 0 || r.aborted || r.error) return false;
+  if (r.finishReason === "length") return false;
+  const text = r.text.trim();
+  return !text || announcesAction(text) || text.endsWith(":");
+}

package/lib/chat/events.ts

@@ -185,6 +185,8 @@ export type ChatItem =
       input: unknown;
       status: ToolStatus;
       output?: string;
+      // How it ended ("exit 1", "HTTP 404"), kept when the output is deferred.
+      outcome?: string;
       diff?: FileDiff;
       // When it finished, to show how long a step took.
       endedAt?: number;

package/lib/chat/group.ts

@@ -1,12 +1,14 @@
 import type { ChatItem } from "./events";
 import { readingOrder } from "./reading-order";
+import { stepCounts, type StepCounts } from "./tool-outcome";
 import { eventTurnAt, type EventTurn } from "./turns";
 
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 
 export type TimelineBlock =
-  | { type: "item"; item: ChatItem }
+  // `steps` rides on the end of a stopped or failed turn: what ran in it.
+  | { type: "item"; item: ChatItem; steps?: StepCounts }
   | { type: "tools"; id: string; tools: ToolItem[] }
   | { type: "undone"; id: string; undo: UndoItem; items: ChatItem[] }
   // Consecutive turns an event started, with the reply to each.
@@ -30,6 +32,8 @@ export function groupTimeline(
   const items = opts.foldEvents ? readingOrder(all) : all;
   const blocks: TimelineBlock[] = [];
   let tools: ToolItem[] = [];
+  // Every tool call since the last turn ended, grouped or not.
+  let turnTools: ToolItem[] = [];
   const flush = () => {
     if (tools.length) blocks.push({ type: "tools", id: tools[0].id, tools });
     tools = [];
@@ -74,8 +78,10 @@ export function groupTimeline(
       i = end;
     } else if (item.kind === "tool" && STANDALONE_TOOLS.has(item.name)) {
       flush();
+      turnTools.push(item);
       blocks.push({ type: "item", item });
     } else if (item.kind === "tool") {
+      turnTools.push(item);
       tools.push(item);
     } else if (item.kind === "reasoning" && tools.length) {
       continue;
@@ -91,7 +97,15 @@ export function groupTimeline(
       continue;
     } else {
       flush();
-      blocks.push({ type: "item", item });
+      const cut =
+        item.kind === "turn_end" &&
+        (item.interrupted || item.ended?.reason === "error");
+      blocks.push(
+        cut && turnTools.length
+          ? { type: "item", item, steps: stepCounts(turnTools) }
+          : { type: "item", item }
+      );
+      if (item.kind === "turn_end") turnTools = [];
     }
   }
   flush();
@@ -123,7 +137,13 @@ function undoneRanges(items: ChatItem[]): Map<number, number> {
 // until they change, so a streamed delta re-renders only its own block.
 export function sameBlock(a: TimelineBlock, b: TimelineBlock): boolean {
   if (a === b) return true;
-  if (a.type === "item" && b.type === "item") return a.item === b.item;
+  if (a.type === "item" && b.type === "item")
+    return (
+      a.item === b.item &&
+      a.steps?.total === b.steps?.total &&
+      a.steps?.ok === b.steps?.ok &&
+      a.steps?.failed === b.steps?.failed
+    );
   if (a.type === "tools" && b.type === "tools")
     return sameItems(a.tools, b.tools);
   if (a.type === "undone" && b.type === "undone")

package/lib/chat/page.ts

@@ -1,5 +1,6 @@
 import { db } from "../db";
 import type { ChatItem, ToolBody } from "./events";
+import { toolCode } from "./tool-outcome";
 
 // A conversation opens on its latest items and pages older ones in as the
 // reader scrolls up, so a long one costs what's on screen, not its history.
@@ -23,8 +24,10 @@ export function lighten(item: ChatItem): ChatItem {
   if (item.kind !== "tool" || (item.output === undefined && !item.diff))
     return item;
   const { output, diff, ...rest } = item;
+  const outcome = toolCode(output);
   return {
     ...rest,
+    ...(outcome ? { outcome } : {}),
     deferred: true,
     ...(diff ? { hasDiff: true } : {}),
     ...(output ? { hasOutput: true } : {}),

package/lib/chat/tool-outcome.ts

@@ -0,0 +1,45 @@
+import type { ToolItem } from "./group";
+
+const EDGE = 4096;
+
+// A short label for how a command ended, read from its output: the last HTTP
+// status line (a redirect chain reports where it landed) or an exit code.
+export function toolCode(output?: string): string | undefined {
+  if (!output) return undefined;
+  const text =
+    output.length > EDGE * 2
+      ? `${output.slice(0, EDGE)}\n${output.slice(-EDGE)}`
+      : output;
+  const http = [...text.matchAll(/^HTTP\/[\d.]+ (\d{3})/gm)].pop();
+  if (http) return `HTTP ${http[1]}`;
+  const exit = [
+    ...text.matchAll(
+      /(?:^Exit code |Command exited with code |exit (?:code|status)[:= ]+)(\d+)/gim
+    ),
+  ].pop();
+  return exit ? `exit ${exit[1]}` : undefined;
+}
+
+export const toolOutcome = (tool: ToolItem): string | undefined =>
+  tool.outcome ?? toolCode(tool.output);
+
+export interface StepCounts {
+  total: number;
+  ok: number;
+  failed: number;
+  // Never finished: the turn stopped first.
+  stopped: number;
+  running: number;
+}
+
+export function stepCounts(tools: ToolItem[]): StepCounts {
+  const n = (s: ToolItem["status"]) =>
+    tools.filter((t) => t.status === s).length;
+  return {
+    total: tools.length,
+    ok: n("done"),
+    failed: n("error"),
+    stopped: n("stopped"),
+    running: n("running"),
+  };
+}

package/lib/db/migrations/20261023T1200_host_info.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261023T1200_host_info",
+  up: (db) => {
+    // What a linked machine says about itself (GET /api/machine), kept so its
+    // name, OS and addresses show while it is offline. Foreign keys aren't
+    // enforced here, so deleteHost removes the row.
+    db.exec(`CREATE TABLE IF NOT EXISTS host_info (
+      host_id TEXT PRIMARY KEY REFERENCES hosts(id) ON DELETE CASCADE,
+      name TEXT,
+      hostname TEXT,
+      os TEXT,
+      arch TEXT,
+      connect_machine_id TEXT,
+      addresses TEXT NOT NULL DEFAULT '[]',
+      fetched_at INTEGER NOT NULL DEFAULT 0
+    )`);
+  },
+} satisfies Migration;

package/lib/db/types.ts

@@ -325,4 +325,8 @@ export interface Host {
   // who unlinked it.
   peer_state?: "active" | "suspended" | "unlinked" | null;
   peer_note?: string | null;
+  // What the machine reported about itself (host_info), when it has.
+  hostname?: string | null;
+  os?: string | null;
+  arch?: string | null;
 }

package/lib/drafts.ts

@@ -63,7 +63,13 @@ export function newDraft(
   id: string,
   project: DraftProject | null,
   carry: Carry,
-  opts: { openPr?: boolean; now?: number; workspaceId?: string | null } = {}
+  opts: {
+    openPr?: boolean;
+    now?: number;
+    workspaceId?: string | null;
+    // Where a scratch chat starts: the machine the sidebar is narrowed to.
+    hostId?: string | null;
+  } = {}
 ): Draft {
   const real = project && !project.is_uncategorized ? project : null;
   const agentType = real?.agent_type ?? carry.agentType ?? "claude";
@@ -71,7 +77,7 @@ export function newDraft(
     id,
     projectId: real?.id ?? null,
     workspaceId: real ? null : (opts.workspaceId ?? null),
-    hostId: real?.host_id || "local",
+    hostId: real?.host_id || opts.hostId || "local",
     agentType,
     model: resolveModelForAgent(
       agentType,

package/lib/hosts/index.ts

@@ -1,5 +1,7 @@
 import { randomUUID } from "crypto";
 import { getDb, type Host } from "../db";
+import { machineName } from "../claims/machine";
+import { setThisMachineName, thisMachine } from "../machines/identity";
 import {
   LOCAL_HOST_ID,
   isValidSshTarget,
@@ -19,6 +21,18 @@ export const LOCAL_HOST: Host = {
   created_at: "",
 };
 
+/** This machine as a host row, under its real (or user-set) name. */
+export function localHost(): Host {
+  const me = thisMachine();
+  return {
+    ...LOCAL_HOST,
+    name: me.name,
+    hostname: me.hostname,
+    os: me.os,
+    arch: me.arch,
+  };
+}
+
 export function isRemoteHost(hostId: string | null | undefined): boolean {
   return !!hostId && hostId !== LOCAL_HOST_ID;
 }
@@ -38,18 +52,20 @@ export function listRemoteHosts(): Host[] {
           (SELECT p.suspended_reason FROM peer_links p WHERE p.host_id = h.id),
           (SELECT u.reason FROM peer_unlinked u WHERE u.host_id = h.id
             ORDER BY u.at DESC LIMIT 1))
-        END AS peer_note
-         FROM hosts h ORDER BY sort_order, created_at`
+        END AS peer_note,
+        i.hostname AS hostname, i.os AS os, i.arch AS arch
+         FROM hosts h LEFT JOIN host_info i ON i.host_id = h.id
+         ORDER BY h.sort_order, h.created_at`
     )
     .all() as Host[];
 }
 
 export function listHosts(): Host[] {
-  return [LOCAL_HOST, ...listRemoteHosts()];
+  return [localHost(), ...listRemoteHosts()];
 }
 
 export function getHost(hostId: string | null | undefined): Host | null {
-  if (!isRemoteHost(hostId)) return LOCAL_HOST;
+  if (!isRemoteHost(hostId)) return localHost();
   return (
     (getDb().prepare(`SELECT * FROM hosts WHERE id = ?`).get(hostId) as
       Host | undefined) ?? null
@@ -59,7 +75,11 @@ export function getHost(hostId: string | null | undefined): Host | null {
 /** A machine by its name (any case) or id. */
 export function hostIdNamed(ref: string): string {
   const want = ref.trim().toLowerCase();
-  if (["local", "here", "this machine"].includes(want)) return LOCAL_HOST_ID;
+  if (
+    ["local", "here", "this machine"].includes(want) ||
+    machineName().toLowerCase() === want
+  )
+    return LOCAL_HOST_ID;
   const host = listRemoteHosts().find(
     (h) => h.id === ref || h.name.toLowerCase() === want
   );
@@ -109,6 +129,7 @@ export function deleteHost(hostId: string): void {
   }
   db.prepare(`DELETE FROM host_links WHERE host_id = ?`).run(hostId);
   db.prepare(`DELETE FROM peer_links WHERE host_id = ?`).run(hostId);
+  db.prepare(`DELETE FROM host_info WHERE host_id = ?`).run(hostId);
   db.prepare(`DELETE FROM hosts WHERE id = ?`).run(hostId);
 }
 
@@ -139,3 +160,20 @@ export function hostExecFile(
 ): Promise<ExecResult> {
   return runFileOnTarget(sshTargetFor(hostId), file, args, timeout);
 }
+
+/** Rename a machine; this one's name is the one Work across machines shows. */
+export function renameHost(hostId: string, raw: string): string {
+  if (!isRemoteHost(hostId)) return setThisMachineName(raw);
+  const name = raw.trim().slice(0, 60);
+  if (!name) throw new Error("Name is required");
+  const db = getDb();
+  if (!db.prepare(`SELECT 1 FROM hosts WHERE id = ?`).get(hostId))
+    throw new Error("Unknown host");
+  const clash = db
+    .prepare(`SELECT 1 FROM hosts WHERE lower(name) = lower(?) AND id != ?`)
+    .get(name, hostId);
+  if (clash || name.toLowerCase() === machineName().toLowerCase())
+    throw new Error(`Another machine is already called "${name}"`);
+  db.prepare(`UPDATE hosts SET name = ? WHERE id = ?`).run(name, hostId);
+  return name;
+}

package/lib/machines/browser.ts

@@ -0,0 +1,37 @@
+/**
+ * Which machine the browser is on, when the request says. Only what the
+ * server itself saw counts: the gate's trust verdict (loopback means an
+ * unproxied request from this machine) and the socket's remote address.
+ * Through Connect or a proxy the address is the tunnel's, so nothing is
+ * claimed and the person says so once per browser instead.
+ */
+
+import { plainAddress } from "../security/auth";
+
+export interface BrowserMachine {
+  /** "local", a host id, or null when it can't be told. */
+  hostId: string | null;
+  how: "loopback" | "address" | null;
+}
+
+export interface KnownMachine {
+  hostId: string;
+  addresses: string[];
+}
+
+export function browserMachine(
+  trust: string | null,
+  remote: string | null,
+  own: string[],
+  others: KnownMachine[]
+): BrowserMachine {
+  if (trust === "loopback") return { hostId: "local", how: "loopback" };
+  const addr = plainAddress(remote ?? "");
+  if (!addr || ["connect", "peer", "unknown"].includes(addr))
+    return { hostId: null, how: null };
+  if (own.includes(addr)) return { hostId: "local", how: "address" };
+  const hit = others.find((m) => m.addresses.includes(addr));
+  return hit
+    ? { hostId: hit.hostId, how: "address" }
+    : { hostId: null, how: null };
+}

package/lib/machines/catalog.ts

@@ -0,0 +1,97 @@
+/**
+ * The agents this machine can run and the models each offers, plus the
+ * Ollama models it serves and which agent runs each. The new-session form
+ * shows exactly this for the machine picked; a linked machine reports its
+ * own through GET /api/machine.
+ */
+
+import { AGENT_OPTIONS } from "../agent-options";
+import { getProviderDefinition } from "../providers/registry";
+import { probeAgents } from "../agents/probe";
+import { discoveredModels } from "../chat/discovered-models";
+import {
+  discoversModels,
+  getDefaultModelForAgent,
+  getModelOptions,
+} from "../model-catalog";
+import type { ChatModel } from "../chat/events";
+import { ollamaModels } from "./ollama";
+import type { CatalogAgent, MachineCatalog, OllamaEntry } from "./types";
+
+const DISCOVER_MS = 6000;
+// Agents that can run a model served by Ollama, in the order to prefer them.
+const LOCAL_RUNNERS = ["opencode", "pi", "omp"] as const;
+
+export const TASK_REMOTE_REASON =
+  "Tasks on another machine run Claude Code only";
+
+const lastSegment = (v: string) => v.slice(v.lastIndexOf("/") + 1);
+
+/** The runner that lists this Ollama tag among its models, if any. */
+export function ollamaRunner(
+  tag: string,
+  byAgent: Record<string, ChatModel[]>
+): OllamaEntry["runsWith"] {
+  for (const agent of LOCAL_RUNNERS) {
+    const models = byAgent[agent] ?? [];
+    const hit =
+      models.find((m) => m.value === `ollama/${tag}`) ??
+      models.find(
+        (m) =>
+          lastSegment(m.value) === tag &&
+          /ollama/i.test(`${m.value} ${m.description ?? ""}`)
+      );
+    if (hit) return { agent, model: hit.value };
+  }
+  return null;
+}
+
+async function discover(agent: string): Promise<ChatModel[]> {
+  return Promise.race([
+    discoveredModels(agent, null),
+    new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("timed out")), DISCOVER_MS).unref?.()
+    ),
+  ]);
+}
+
+export async function machineCatalog(): Promise<MachineCatalog> {
+  const [probes, tags] = await Promise.all([probeAgents(), ollamaModels()]);
+  const found: Record<string, ChatModel[]> = {};
+  const errors: Record<string, string> = {};
+  const wanted = AGENT_OPTIONS.filter(
+    (a) =>
+      probes[a.value]?.installed &&
+      (discoversModels(a.value) || LOCAL_RUNNERS.some((r) => r === a.value))
+  );
+  await Promise.all(
+    wanted.map(async (a) => {
+      if (!discoversModels(a.value)) return;
+      try {
+        found[a.value] = await discover(a.value);
+      } catch (e) {
+        errors[a.value] = e instanceof Error ? e.message : String(e);
+      }
+    })
+  );
+  const agents: CatalogAgent[] = AGENT_OPTIONS.filter(
+    (a) => !getProviderDefinition(a.value)?.legacy || probes[a.value]?.installed
+  ).map((a) => {
+    const base = getModelOptions(a.value);
+    return {
+      agent: a.value,
+      label: a.label,
+      installed: probes[a.value]?.installed ?? false,
+      auth: probes[a.value]?.auth ?? "unknown",
+      hint: probes[a.value]?.hint ?? null,
+      models: [...base, ...(found[a.value] ?? [])],
+      defaultModel: getDefaultModelForAgent(a.value),
+      taskBlocked: a.value === "claude" ? null : TASK_REMOTE_REASON,
+      modelsError: errors[a.value] ?? null,
+    };
+  });
+  return {
+    agents,
+    ollama: tags.map((name) => ({ name, runsWith: ollamaRunner(name, found) })),
+  };
+}

package/lib/machines/identity.ts

@@ -0,0 +1,52 @@
+/**
+ * This machine as it names itself: the one name every surface shows (the
+ * Machines dialog, the new-session chip, Work across machines), its OS and
+ * the addresses another device could reach it at.
+ */
+
+import os from "os";
+import { machineName } from "../claims/machine";
+import { putSetting } from "../settings-store";
+import { currentIdentity } from "../peer/keys";
+import { lanAddresses, tailscaleAddresses } from "../security/net";
+
+export interface MachineIdentity {
+  name: string;
+  hostname: string;
+  os: string;
+  arch: string;
+  connectMachineId: string | null;
+  addresses: string[];
+}
+
+const OS_LABEL: Record<string, string> = {
+  darwin: "macOS",
+  linux: "Linux",
+  win32: "Windows",
+};
+
+export const osLabel = (platform: string = os.platform()) =>
+  OS_LABEL[platform] ?? platform;
+
+export function thisMachine(): MachineIdentity {
+  return {
+    name: machineName(),
+    hostname: os.hostname().split(".")[0] || "machine",
+    os: osLabel(),
+    arch: os.arch(),
+    connectMachineId: currentIdentity()?.machineId ?? null,
+    addresses: [...new Set([...tailscaleAddresses(), ...lanAddresses()])],
+  };
+}
+
+/** A user-set name for this machine; the same one Work across machines shows. */
+export function setThisMachineName(raw: string): string {
+  const name = raw
+    .replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 60);
+  if (!name) throw new Error("Name is required");
+  putSetting("claims.machine_name", name);
+  return name;
+}

package/lib/machines/label.ts

@@ -0,0 +1,36 @@
+/** How a machine is named on every screen, so they all agree. */
+
+export interface Nameable {
+  id: string;
+  name: string;
+}
+
+export const LOCAL_ID = "local";
+
+/**
+ * "spark-54423f (host)" for the machine serving this dashboard, the plain name
+ * for the others; " · you're here" when the browser is on it.
+ */
+export function machineLabel(host: Nameable, browserHostId?: string | null) {
+  const base = host.id === LOCAL_ID ? `${host.name} (host)` : host.name;
+  return browserHostId && browserHostId === host.id
+    ? `${base} · you're here`
+    : base;
+}
+
+/** What a machine reports about itself, as one line. */
+export function machineDetail(h: {
+  name?: string;
+  hostname?: string | null;
+  os?: string | null;
+  arch?: string | null;
+}): string {
+  // Its hostname is only news when the name isn't already it.
+  const hostname =
+    h.hostname && h.hostname.toLowerCase() !== h.name?.toLowerCase()
+      ? h.hostname
+      : null;
+  return [hostname, [h.os, h.arch].filter(Boolean).join(" ")]
+    .filter(Boolean)
+    .join(" · ");
+}

package/lib/machines/ollama.ts

@@ -0,0 +1,32 @@
+/** The models a local Ollama serves, asked of its own API. */
+
+const DEFAULT_URL = "http://127.0.0.1:11434";
+const TIMEOUT_MS = 1500;
+
+export function ollamaBase(
+  env: Record<string, string | undefined> = process.env
+): string {
+  const raw = env.OLLAMA_HOST?.trim();
+  if (!raw) return DEFAULT_URL;
+  const url = /^https?:\/\//.test(raw) ? raw : `http://${raw}`;
+  return url.replace(/\/+$/, "");
+}
+
+/** Model tags, or none when Ollama isn't running or doesn't answer in time. */
+export async function ollamaModels(
+  fetchImpl: typeof fetch = fetch,
+  base = ollamaBase()
+): Promise<string[]> {
+  try {
+    const res = await fetchImpl(`${base}/api/tags`, {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    if (!res.ok) return [];
+    const body = (await res.json()) as { models?: { name?: unknown }[] };
+    return (body.models ?? [])
+      .map((m) => (typeof m.name === "string" ? m.name : ""))
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}