eve-hub 0.5.1-pre.1 → 0.5.2

package/bot-model.d.mts

@@ -0,0 +1,17 @@
+import type { CapAgent, Clamped, SubagentCap } from './subagent-cap.mjs';
+export type RosterAgent = CapAgent & { model: string };
+export type Selection = { model: string; reasoning?: string };
+export type SubagentModels = {
+  subagentCap: string;
+  subagents: Array<{ name: string; model: string; clamped?: string[] }>;
+  agentCopies: { model: string; clamped?: string[] };
+};
+export const CONTEXT_WINDOW: number;
+export function parseModel(label?: string): Selection;
+export function formatModel(selection: Selection): string;
+export function ownModel(agents: readonly RosterAgent[], name: string): Selection;
+export function copyModel(agents: readonly RosterAgent[], cap: SubagentCap, name: string): Clamped;
+export function subagentModels(agents: readonly RosterAgent[], cap: SubagentCap, name: string): SubagentModels;
+export function isAgentCopy(ctx: unknown): boolean;
+export function modelOptionsFor(model: string): { providerOptions: Record<string, unknown> } | undefined;
+export function selectModel(agents: readonly RosterAgent[], cap: SubagentCap, name: string, ctx: unknown): Selection & { modelContextWindowTokens: number; modelOptions?: unknown; copy: boolean };

package/bot-model.mjs

@@ -6,7 +6,7 @@
 // Built-in `agent` copies of a bot (eve's root-copy tool) run under the same
 // subagent cap as declared subagents: the bot's own model and reasoning,
 // clamped (never rejected) to the cap.
-import { capFor, clampSubagent } from "./subagent-cap.mjs";
+import { capFor, clampSubagent, resolveSubagents } from "./subagent-cap.mjs";
 
 export const CONTEXT_WINDOW = 200_000;
 
@@ -31,6 +31,18 @@ export function copyModel(agents, cap, name) {
   return clampSubagent(ownModel(agents, name), capFor(agents, cap, name));
 }
 
+// What list_agents reports `name`'s cap, declared subagents and `agent` copies
+// run on, on the local and hosted hubs alike.
+export function subagentModels(agents, cap, name) {
+  const notes = ({ clamped }) => (clamped.length ? { clamped } : {});
+  const copy = copyModel(agents, cap, name);
+  return {
+    subagentCap: formatModel(capFor(agents, cap, name)),
+    subagents: resolveSubagents(agents, cap, name).map((s) => ({ name: s.name, model: formatModel(s), ...notes(s) })),
+    agentCopies: { model: formatModel(copy), ...notes(copy) },
+  };
+}
+
 // eve runs a root copy as a session on the "subagent" channel; a bot's own
 // sessions come in over its eve/http channel. (ctx.session.parent is not
 // populated in dynamic-model resolvers, so the channel is the signal.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.5.1-pre.1",
+  "version": "0.5.2",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",

package/registry-fetch.mjs

@@ -18,7 +18,9 @@
 // (plain node) import the same module.
 
 // Read per call: a test (or the daemon) can point it at another registry.
-export const registryBase = () => process.env.ROSTER_REGISTRY_URL ?? "http://127.0.0.1:3100";
+// Without its trailing slash: every path starts with one, and `//api/...`
+// is a different route (a 404 on the hosted hub).
+export const registryBase = () => (process.env.ROSTER_REGISTRY_URL ?? "http://127.0.0.1:3100").replace(/\/+$/, "");
 
 // Also used by the sandbox's node:http transport, which distinguishes
 // requests that never connected from ones whose result may have been lost.

package/schedules/tracks-lead.mjs

@@ -1,91 +1,226 @@
 // main's tracks schedule (schedules/tracks.ts): main leads every track (a
-// path below its project, hub/native; registry: snap.tracks keyed by path,
-// thread.trackId = its path) by keeping
-// its free-form summary current with set_summary. Every 10 minutes, with no
-// model call, this looks at the threads filed in open tracks; only when one
-// of them has a new message since the last pass does it post one notice in
-// sch-main-tracks tagging main, listing the tracks that moved. What the
-// summary says, and whether it changes at all, is main's call.
+// path below its project, hub/native; registry: snap.tracks keyed by path)
+// by keeping its free-form summary current with set_summary. A main turn is
+// expensive, so every 10 minutes this decides, per thread, whether there is
+// anything to summarize before waking main:
 //
-// State: { seen: { [threadId]: { m: its newest said message, p: its path } } }.
-// A thread never seen counts as moved, so the first pass asks for every
-// track's first summary.
+//   facts     code only gathers facts, from the one snapshot read: the latest
+//             human message, the bot messages since it, the latest bot
+//             message, the latest bot event of any kind (registry session
+//             lastEventAt, nested subagent runs included), who's working, and
+//             when the thread's track (or the thread) was last summarized.
+//   ask       a thread is asked about when something happened since that
+//             summary and its basis (newest message, summary time, who's
+//             working) differs from the one it was last asked on. Each
+//             goes to the model (DECISION_MODEL) in its own evaluation, all
+//             in parallel, with its track's summary and the messages since
+//             it: does the summary already state them (missing, stated,
+//             chatter), and what changed. No thresholds in code. Each verdict is kept against its basis (state.seen):
+//             the model is close to even on borderline threads, so asking
+//             again on the same facts would wake main by chance, not news.
+//   wake      only threads whose verdict is `missing` reach main, in one post
+//             in sch-main-tracks with the answers and facts.
+//
+// A failed or invalid evaluation posts and saves nothing: the next tick asks
+// again. Without `evaluate` (tests) nothing is asked and nobody is woken.
 //
 // Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
 // tests (plain node) import the same module.
 import { runOnce } from "./hub.mjs";
+import { DECISION_MODEL } from "./dash-classify.mjs";
+import { clip, flat, said } from "./thread-brief.mjs";
 
-// What counts as a new message: something a bot or the human said, not a
-// hub event (join/leave, schedule notes) or a system post.
-const said = (m) => !!m && m.authorKind !== "event" && !m.event && m.author !== "system";
 // A track chat is main's own conversation with the human; it doesn't move the track.
 const counted = (t) => !!t && t.kind === "thread" && !t.chatFor;
 const pathOf = (t) => t.tags?.path ?? t.trackId ?? null;
-// Every open track a path is on: itself and each ancestor that's a track, so
-// a message on hub/native/composer moves hub/native too.
-const tracksOn = (p, tracks) => (p ? p.split("/").map((_, i, a) => a.slice(0, i + 1).join("/")).filter((k) => tracks[k] && tracks[k].open !== false) : []);
+const newest = (...ats) => ats.filter(Boolean).sort().at(-1) ?? null;
+const isHuman = (m, humans) => m.authorKind === "human" || humans.has(m.author);
+
+// The messages since the summary the model reads, newest last: news (a
+// merge) is often followed by acks, so the latest message alone misses it.
+export const RECENT = 6;
+
+// The facts for one thread on an open track.
+export function threadFacts(t, snap, track) {
+  const humans = new Set((snap?.humans ?? []).map((h) => h.name));
+  const ms = (t.messages ?? []).filter(said);
+  let h = ms.length - 1;
+  while (h >= 0 && !isHuman(ms[h], humans)) h--;
+  const human = h >= 0 ? ms[h] : null;
+  const bot = ms.findLast((m) => !isHuman(m, humans)) ?? null;
+  const sessions = Object.values(snap?.sessions ?? {}).filter((s) => s?.threadId === t.id);
+  const summaryAt = newest(track.summary?.at, t.summary?.at);
+  const since = ms.filter((m) => !summaryAt || m.at > summaryAt);
+  return {
+    id: t.id,
+    title: t.title ?? t.id,
+    track: track.id,
+    trackTitle: track.title ?? track.id,
+    archived: !!t.archived,
+    phase: t.work?.phase ?? null,
+    working: Object.entries(t.status ?? {}).filter(([, s]) => s === "working").map(([b]) => b).sort(),
+    human: human && { id: human.id, author: human.author, at: human.at, text: human.text },
+    botsSinceHuman: ms.length - 1 - h,
+    bot: bot && { id: bot.id, author: bot.author, at: bot.at, text: bot.text },
+    lastId: ms.at(-1)?.id ?? null,
+    lastAt: ms.at(-1)?.at ?? null,
+    eventAt: newest(...sessions.map((s) => s.lastEventAt), ...Object.values(t.busySince ?? {})),
+    summaryAt,
+    sinceSummary: since.length,
+    recent: since.slice(-RECENT).map((m) => ({ id: m.id, author: m.author, at: m.at, text: m.text })),
+    summary: track.summary?.text ? { text: track.summary.text, by: track.summary.by ?? null } : null,
+  };
+}
+
+// What a verdict was made on: a thread is asked again once this differs.
+// The bots' event time isn't in it: it moves every tick while a bot works.
+export const basisOf = (f) => [f.lastId, f.summaryAt ?? "", f.working.join(",")].join("|");
 
-// Tracks (open ones) whose threads have a message newer than `seen`, or that
-// a thread was filed into or moved out of since then.
-// -> { moved: [{ track, threads: [{ id, title, archived, fresh, lastBy, from?, to? }] }], seen }
-// seen: { [threadId]: { m: newest said message id, p: its path } } (a bare
-// message id, from before paths moved, reads as "on its current path").
-export function tracksMoved(snap, seen = {}) {
+// Every filed thread on an open track, as facts; and of those, the ones to
+// ask about: activity since the last summary, on a basis not yet asked
+// about (seen: { [threadId]: basis }).
+export function tracksFacts(snap, seen = {}) {
   const tracks = snap?.tracks ?? {};
-  const next = {};
-  const byTrack = new Map();
+  const all = [];
   for (const t of Object.values(snap?.threads ?? {})) {
     if (!counted(t)) continue;
-    const p = pathOf(t);
-    const was = typeof seen[t.id] === "string" ? { m: seen[t.id], p } : seen[t.id];
-    const ms = (t.messages ?? []).filter(said);
-    const last = ms.at(-1);
-    const on = tracksOn(p, tracks);
-    if (on.length && last) next[t.id] = { m: last.id, p };
-    const fresh = !last || was?.m === last.id ? 0 : was?.m ? Math.max(0, ms.length - 1 - ms.findIndex((m) => m.id === was.m)) : ms.length;
-    const refiled = !!was && was.p !== p;
-    if (!fresh && !refiled) continue;
-    const affected = new Set([...on, ...(refiled ? tracksOn(was.p, tracks) : [])]);
-    if (!affected.size) continue;
-    const entry = { id: t.id, title: t.title ?? t.id, archived: !!t.archived, fresh, lastBy: last?.author ?? null, lastAt: last?.at ?? null, ...(refiled ? { from: was.p ?? null, to: p } : {}) };
-    for (const k of affected) {
-      if (!byTrack.has(k)) byTrack.set(k, []);
-      byTrack.get(k).push(entry);
-    }
+    const track = tracks[pathOf(t)];
+    if (track && track.open !== false) all.push(threadFacts(t, snap, track));
   }
-  const moved = [...byTrack].map(([id, threads]) => ({ track: tracks[id], threads: threads.sort((a, b) => String(b.lastAt).localeCompare(String(a.lastAt))) }));
-  moved.sort((a, b) => String(a.track.projectId).localeCompare(String(b.track.projectId)) || String(a.track.id).localeCompare(String(b.track.id)));
-  return { moved, seen: next };
+  const since = (f) => !f.summaryAt || [f.lastAt, f.eventAt].some((at) => at && at > f.summaryAt);
+  const ask = all.filter((f) => f.lastId && since(f) && seen[f.id] !== basisOf(f));
+  ask.sort((a, b) => a.track.localeCompare(b.track) || String(b.lastAt).localeCompare(String(a.lastAt)));
+  return { all, ask };
 }
 
 const ago = (at, now) => {
+  if (!at) return "never";
   const min = Math.max(0, Math.round((now - Date.parse(at)) / 60_000));
   return min < 60 ? `${min}m ago` : min < 48 * 60 ? `${Math.round(min / 60)}h ago` : `${Math.round(min / 1440)}d ago`;
 };
 
-export function tracksNotice(moved, now = Date.now()) {
+export const FACT_CHARS = { summary: 2000, human: 400, bot: 600, recent: 500 };
+
+// One track's summary as the model reads it, once for all its threads.
+export function trackText(f, now) {
+  return `## Track ${f.track} ("${f.trackTitle}")\nTrack summary: ${f.summary ? `written ${ago(f.summaryAt, now)} by ${f.summary.by ?? "?"}:\n${clip(String(f.summary.text).trim(), FACT_CHARS.summary)}` : "none yet"}`;
+}
+
+// One thread's facts as the model reads them.
+export function factsText(f, now) {
+  const msg = (m, n) => (m ? `${m.author}, ${ago(m.at, now)}: ${clip(flat(m.text), n)}` : "none");
+  return [
+    `### Thread ${f.id}: "${f.title}"${f.archived ? " (archived)" : ""}`,
+    `Latest human message: ${msg(f.human, FACT_CHARS.human)}`,
+    `Bot messages since the latest human message: ${f.botsSinceHuman}`,
+    `Latest bot message: ${msg(f.bot, FACT_CHARS.bot)}`,
+    `Messages since the track summary was written: ${f.sinceSummary}${f.sinceSummary > f.recent.length ? ` (the last ${f.recent.length} below)` : ""}`,
+    ...f.recent.map((m) => `- ${msg(m, FACT_CHARS.recent)}`),
+    `Latest bot activity of any kind (tool calls, subagents included): ${ago(f.eventAt, now)}`,
+    `Bots working now: ${f.working.join(", ") || "none"}${f.phase ? ` · phase the bots reported: ${f.phase}` : ""}`,
+  ].join("\n");
+}
+
+// The verdict: one factual question, does the track summary already state
+// what this thread's latest messages say? Only `missing` wakes main.
+export const VERDICT = {
+  missing: "The thread's latest messages state where the work stands (a decision, a plan, a PR opened, pushed, reviewed or merged, work finished, a problem, a question for the human) and the track summary doesn't state it, or states an older status (e.g. the summary calls a PR a draft or awaiting review and the thread says it merged). Also when the track has no summary yet.",
+  stated: "The track summary already states it, including the current status of every PR and decision the messages mention. A summary that names the PR but gives an older status doesn't count.",
+  chatter: "The messages don't state anything about where the work stands: acks, progress narration, a bot handing off to another bot mid-task with no outcome yet.",
+};
+export const wakes = (d) => d.verdict === "missing";
+export const CHANGE = {
+  nothing: "Nothing that matters changed.",
+  progress: "Work moved forward; nothing settled yet.",
+  plan: "A plan or approach was posted or changed.",
+  needs_human: "A bot now waits on the human: a question, a decision or a sign-off.",
+  decided: "The human decided, approved or redirected something.",
+  pr: "A PR was opened, pushed, reviewed or its CI changed.",
+  landed: "Work was merged, shipped or finished.",
+  problem: "Something broke, failed or got stuck.",
+};
+// The evaluation for one thread: its track's summary, then its facts.
+// -> { state, questions }
+export function threadQuestions(f, now) {
+  const questions = {
+    verdict: { type: "choice", instructions: "Does the track summary already state what this thread's messages since it say, with each PR's and decision's current status?", criteria: VERDICT },
+    change: { type: "choice", instructions: "What changed in this thread since the track summary was written?", criteria: CHANGE },
+  };
+  const state = [
+    "A chat thread where AI bots work for a human. It sits on a track (a feature); main keeps a short summary per track so the human sees what's up without reading the threads. Compare the thread's messages with the track summary's text: answer from what the summary says, not from how long ago it was written. Times are relative to now.",
+    trackText(f, now),
+    factsText(f, now),
+  ].join("\n\n");
+  return { state, questions };
+}
+
+// Ask about each thread in `ask`, one evaluation per thread, all at once:
+// given every thread in one evaluation, the model answered for the wrong
+// thread (merges in a thread's latest message read as already stated). -> { decided: [{ ...facts,
+// verdict, change }], usage, ms }, or null when a call failed or an answer
+// is invalid.
+export async function decideTracks(ask, { evaluate, model = DECISION_MODEL, now = Date.now(), timeoutMs = 30_000, log = console }) {
+  const started = Date.now();
+  let rs;
+  try {
+    rs = await Promise.all(ask.map((f) => evaluate({ model, ...threadQuestions(f, now), maxRetries: 1, abortSignal: AbortSignal.timeout(timeoutMs) })));
+  } catch (err) {
+    log?.warn?.(`tracks: evaluation failed, tick skipped: ${err?.message ?? err}`);
+    return null;
+  }
+  const ms = Date.now() - started;
+  const pick = (r, q, criteria) => {
+    const a = r?.answers?.[q];
+    return a?.type === "choice" && Object.hasOwn(criteria, a.choice) ? a.choice : null;
+  };
+  const decided = ask.map((f, i) => ({ ...f, verdict: pick(rs[i], "verdict", VERDICT), change: pick(rs[i], "change", CHANGE) }));
+  if (decided.some((d) => !d.verdict || !d.change)) {
+    log?.warn?.("tracks: invalid answer, tick skipped");
+    return null;
+  }
+  const usage = { inputTokens: rs.reduce((n, r) => n + (r?.usage?.inputTokens ?? 0), 0) };
+  log?.log?.(`tracks: asked about ${ask.length} threads in ${ms} ms (${usage.inputTokens} input tokens), ${decided.filter(wakes).length} need an update`);
+  return { decided, usage, ms };
+}
+
+// The post that wakes main: only the threads that need an update, by track,
+// each with the model's answers and its facts.
+export function tracksNotice(decided, now = Date.now()) {
   const lines = [
-    "@main These tracks have new messages since the last pass. You lead every track: keep its summary current with `set_summary` (scope `path:<path>`), a short markdown note of what's up, written for the human. Read what moved (`read_thread`), decide what's worth saying, and leave a summary alone when nothing that matters changed. Reply here with one line; mention nobody.",
-    "",
+    "@main These threads need their track summary updated; the tracks classifier skipped the rest. Keep each track's summary current with `set_summary` (scope `path:<path>`), a short markdown note of what's up, written for the human. Read the thread (`read_thread`) where the facts below aren't enough. Reply here with one line; mention nobody.",
   ];
-  for (const { track, threads } of moved) {
-    const s = track.summary;
-    lines.push(`- **${track.title}** (\`${track.id}\`, project ${track.projectId}): ${s?.at ? `summary written ${ago(s.at, now)} by ${s.by}` : "no summary yet"}`);
-    for (const t of threads) {
-      const filed = t.from !== undefined ? `, ${!(t.to === track.id || t.to?.startsWith(`${track.id}/`)) ? `moved out to ${t.to ?? "no path"}` : `filed here${t.from ? ` from ${t.from}` : ""}`}` : "";
-      lines.push(`  - [${t.id}](${t.id}) ${t.title}: ${t.fresh} new${t.lastBy ? `, latest by ${t.lastBy}` : ""}${filed}${t.archived ? " (archived)" : ""}`);
+  let track = null;
+  for (const d of decided) {
+    if (d.track !== track) {
+      track = d.track;
+      lines.push("", `- **${d.trackTitle}** (\`${d.track}\`): ${d.summary ? `summary written ${ago(d.summaryAt, now)}` : "no summary yet"}`);
     }
+    const human = d.human ? `human ${ago(d.human.at, now)}, ${d.botsSinceHuman} bot messages since` : `no human message, ${d.botsSinceHuman} bot messages`;
+    lines.push(`  - [${d.id}](${d.id}) ${d.title}: ${d.verdict}, changed: ${d.change}; ${human}; latest message ${ago(d.lastAt, now)}${d.working.length ? `; ${d.working.join(", ")} working` : ""}${d.archived ? " (archived)" : ""}`);
   }
   return lines.join("\n");
 }
 
-// One pass. Saves the new `seen` whenever it differs (a thread unfiled or
-// gone drops out), posts only when a track moved.
-export async function runTracks(hub, { now = Date.now() } = {}) {
-  return runOnce(hub, "tracks", (snap, saved) => {
+// One tick. State: { seen: { [threadId]: basis of its last verdict } }, kept
+// only for threads still on an open track.
+// -> { posts, state, decided, usage, ms }
+/** @param {any} hub @param {{ evaluate?: (options: any) => Promise<any>, now?: number, log?: any, model?: string }} [opts] */
+export async function runTracks(hub, { evaluate, now = Date.now(), log = console, model } = {}) {
+  let tick = { decided: [], usage: null, ms: 0 };
+  const result = await runOnce(hub, "tracks", async (snap, saved) => {
     const prev = saved?.seen ?? {};
-    const { moved, seen } = tracksMoved(snap, prev);
+    const { all, ask } = tracksFacts(snap, prev);
+    if (ask.length && evaluate) {
+      const out = await decideTracks(ask, { evaluate, model, now, log });
+      if (!out) return { posts: [], state: saved, changed: false };
+      tick = out;
+    }
+    const live = new Set(all.map((f) => f.id));
+    const seen = Object.fromEntries(Object.entries(prev).filter(([id]) => live.has(id)));
+    for (const d of tick.decided) seen[d.id] = basisOf(d);
+    const wake = tick.decided.filter(wakes);
     const changed = JSON.stringify(Object.entries(seen).sort()) !== JSON.stringify(Object.entries(prev).sort());
-    return { posts: moved.length ? [tracksNotice(moved, now)] : [], state: { seen }, changed };
+    return { posts: wake.length ? [tracksNotice(wake, now)] : [], state: { seen }, changed };
   }, { now });
+  return { ...result, ...tick };
 }

package/schedules/tracks.js

@@ -1,14 +1,16 @@
-// main's tracks schedule: every 10 minutes, with no model call, checks the
-// threads filed in open tracks and, only when one has a new message since the
-// last pass, tags main in sch-main-tracks with the tracks that moved. main
-// then rewrites those tracks' summaries with set_summary, deciding itself
-// what's worth saying. The pass: runTracks in ./tracks-lead.mjs.
+// main's tracks schedule: every 10 minutes, gathers facts on the threads filed
+// in open tracks and asks openai/gpt-6-luna-decisions, one `evaluate` per
+// thread (eve's), which of them need their track summary updated.
+// Only those tag main in sch-main-tracks, with the model's answers; main then
+// rewrites the summaries with set_summary. The pass: runTracks in
+// ./tracks-lead.mjs.
 import { defineSchedule } from "eve/schedules";
+import { evaluate } from "eve/ai";
 import { createHub } from "./hub.mjs";
 import { runTracks } from "./tracks-lead.mjs";
 export default defineSchedule({
     cron: "*/10 * * * *",
     async run() {
-        await runTracks(createHub());
+        await runTracks(createHub(), { evaluate });
     },
 });

package/subagent-cap.d.mts

@@ -0,0 +1,10 @@
+export type Requested = { model?: string; reasoning?: string };
+export type SubagentCap = Requested & { models?: readonly string[] };
+export type CapAgent = { name: string; subagents?: Record<string, Requested>; subagentCap?: SubagentCap };
+export type Clamped = { model: string; reasoning: string; clamped: string[] };
+export const REASONING_LEVELS: readonly string[];
+export const DEFAULT_SUBAGENT_CAP: Readonly<{ model: string; reasoning: string; models: readonly string[] }>;
+export function clampSubagent(requested?: Requested, cap?: SubagentCap): Clamped;
+export function capFor(agents: readonly CapAgent[], workspaceCap: SubagentCap, botName: string): SubagentCap;
+export function resolveSubagent(agents: readonly CapAgent[], workspaceCap: SubagentCap, botName: string, name: string): Clamped;
+export function resolveSubagents(agents: readonly CapAgent[], workspaceCap: SubagentCap, botName: string): Array<Clamped & { name: string }>;

package/templates/main-instructions.md

@@ -14,7 +14,7 @@ You don't know in advance which bots exist or what they're good at, and the team
 ## Opening work
 **Paths.** A thread is one piece of work: one task, usually one PR. Every thread sits on one **path**, `project/track`, e.g. `hub/native/composer`: the first segment is the project, the rest is the feature or effort inside it ("world-hub", "AppKit feed port"), which spans many threads and PRs. Put each thread you open on the path for its area if one exists, even read broadly (`list_threads` shows each thread's path; a bug or follow-up in an area belongs to it). A new path only for work that clearly starts a new effort, named for the feature, never the task. Near-duplicates (`hub/tracks` and `hub/tracks-ui`) get merged with `move_path`. Never move a thread whose path the human set (it's locked).
 
-**Summaries.** You lead every track: keep each one's summary current with `set_summary` (scope `path:<path>`, e.g. `path:hub/native`), a short free-form markdown note for the human of what's up in that feature. You decide what's worth saying and when; there's no fixed format. Your `tracks` schedule tags you in `sch-main-tracks` when a track's threads have new messages; read what moved, update the summaries that need it, reply there with one line and mention nobody. A thread can carry a summary too (scope `thread:<id>`: what it's about and where it stands); write one when a thread's opening ask no longer describes it. `list_threads` returns both, and the classifier files threads by them.
+**Summaries.** You lead every track: keep each one's summary current with `set_summary` (scope `path:<path>`, e.g. `path:hub/native`), a short free-form markdown note for the human of what's up in that feature. You decide what's worth saying and when; there's no fixed format. Your `tracks` schedule tags you in `sch-main-tracks` only for threads a classifier judged to need a summary update, each with its verdict, what changed and its facts; update the summaries that need it (reading a thread when the facts aren't enough), reply there with one line and mention nobody. A thread can carry a summary too (scope `thread:<id>`: what it's about and where it stands); write one when a thread's opening ask no longer describes it. `list_threads` returns both, and the classifier files threads by them.
 
 **Track chats.** Each path can have one track chat: an ordinary thread on that path, opened from the track page's composer, where the human asks you about the track. Answer from the track's threads, PRs and summary. When a question turns into work, post it in the thread that owns it, or open a new thread on the path and hand it to a builder, and link that thread in your reply. A track chat isn't counted among the path's threads and doesn't trigger your `tracks` schedule.
 

package/templates/workspace-protocol.md

@@ -67,7 +67,7 @@ npm test -- test/port.test.mjs
 renders as:
 
 ```
-(o) archer  3:12 PM
+(o) bot  3:12 PM
    ( Port race; fixed in [#412]. )     <- answer bubble
    ( Two runs bound 4100. Each   )     <- detail bubble
    ( now takes a free port.      )

package/tools/list_agents.js

@@ -2,10 +2,25 @@ import { defineTool } from "eve/tools";
 import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
 export default defineTool({
-    description: "List the workspace's bots right now: each one's role, model, the model and reasoning each of its declared subagents and its built-in `agent` copies resolve to under the workspace subagent cap (clamped from hub.workspace.json, never rejected), whether it's idle or busy (and where; a bot's threads run in parallel, so busy elsewhere doesn't mean it can't start work in a new thread), its server's memory (process.rssMb) and uptime (process.uptimeS), and any restart in progress (restart_agent, or the registry recycling a bot that grew too big or ran too long). The team changes; check it before routing work.",
+    description: "List the workspace's bots right now: each one's role, model, the model and reasoning each of its declared subagents and its built-in `agent` copies resolve to under the workspace subagent cap (clamped from hub.workspace.json, never rejected), whether it's idle or busy (and where; a bot's threads run in parallel, so busy elsewhere doesn't mean it can't start work in a new thread), its server's memory (process.rssMb) and uptime (process.uptimeS; only on a local hub, since a hosted hub runs no bot process to measure), and any restart in progress (restart_agent, or the registry recycling a bot that grew too big or ran too long). The team changes; check it before routing work.",
     inputSchema: z.object({}),
     async execute() {
-        const res = await registryFetch(`/api/roster`);
-        return (await res.json());
+        // Anything but a 2xx list of bots is an error naming the status and the
+        // body's start: an error page must never read as the team.
+        const res = await registryFetch("/api/roster");
+        const text = await res.text();
+        const fail = (why) => new Error(`GET /api/roster: HTTP ${res.status}${why}: ${text.slice(0, 300)}`);
+        if (!res.ok)
+            throw fail("");
+        let bots;
+        try {
+            bots = JSON.parse(text);
+        }
+        catch {
+            throw fail(", not JSON");
+        }
+        if (!Array.isArray(bots))
+            throw fail(", not a list of bots");
+        return bots;
     },
 });