eve-hub 0.6.42 → 0.6.44

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.6.44
+
+### Patch Changes
+
+- The mention rule (mentionTokens and codeRanges) lives in mention-tokens.mjs with no imports, so the composer's fuzz harness loads the server's own source; mention-gate re-exports codeRanges.
+
+## 0.6.43
+
+### Patch Changes
+
+- Every bot is given the team model (who is on the team, where each runs, each bot's real tools from its eve runtime, who hands work to whom) as a memory slot that re-sends only when it changes, hosted bots included; `list_agents` is on every bot and reports each bot's kind, place and tools.
+
 ## 0.6.42
 
 ### Patch Changes

package/execution-context.mjs

@@ -39,15 +39,13 @@ export function deploymentFacts(env = process.env) {
 
 const list = (items) => items.map((item) => `\`${item}\``).join(", ");
 
-export function hostedContext({ bot, roster, kit, removed, deployment: d }, options) {
-  const mac = roster.filter((agent) => agent.runsOn === "local").map((agent) => agent.name);
-  const cloud = roster.filter((agent) => agent.runsOn !== "local").map((agent) => agent.name);
+export function hostedContext({ bot, kit, removed, deployment: d }, options) {
   const dashboard = d.team && d.project ? `https://vercel.com/${d.team}/${d.project}` : undefined;
   const lines = [
     "## Execution context",
     `You are \`${bot}\`, an eve agent deployed on Vercel, not on a laptop: \`hub.workspace.json\` defines you as hosted.`,
     "",
-    `- **Workspace:** ${cloud.length ? `${list(cloud)} run on Vercel` : "no bot runs on Vercel"}${mac.length ? `; ${list(mac)} run on the owner's Mac through the hub runner` : ""}. One hosted hub holds the threads and routes messages to each.`,
+    "- **Workspace:** one hosted hub holds the threads and routes messages to each bot. Who is on the team, where each bot runs and what each can do come live from the hub: the team model message at the top of your turn (when it changes) and `list_agents`.",
     `- **Package:** your tools, hooks, channel and instructions come from the \`eve-hub\` package, version ${kit}.`,
     `- **Deployment:** ${[
       (d.project ?? d.projectId) && `project \`${d.project ?? d.projectId}\``,

package/kit-modules.json

@@ -8,6 +8,7 @@
   "instructions/main",
   "instructions/protocol",
   "memory/bot",
+  "memory/team",
   "memory/workspace",
   "schedules/compact",
   "schedules/dash",

package/memory/team.d.ts

@@ -0,0 +1,20 @@
+declare const recall: ({ messages }: {
+    messages: readonly unknown[];
+}) => Promise<{
+    messages: {
+        id: string;
+        content: string;
+    }[];
+}>;
+declare const _default: import("eve/memory").DefinedMemory<{
+    readonly description: "The team: who is on it, what each bot can do, and who hands work to whom.";
+    readonly namespace: "hub-team-memory";
+    readonly scope: "workspace";
+    readonly provider: {
+        readonly recall: {
+            "turn.started": typeof recall;
+            "compaction.completed": typeof recall;
+        };
+    };
+}>;
+export default _default;

package/memory/team.js

@@ -0,0 +1,38 @@
+import { defineMemory, defineMemoryProvider } from "eve/memory";
+import { registryFetch } from "../registry-fetch.mjs";
+import { teamRecall } from "../team.mjs";
+// The team model (team.mjs) as an eve memory slot: roster, each bot's tools
+// and the handoff rules, from the hub's GET /api/team. Recall runs at the start
+// of every turn and after compaction, and adds one message only when the team
+// differs from what this session was last given, so a turn where nothing
+// changed carries nothing. A hub that can't answer within 5 s fails the recall, not the turn.
+const warned = new Set();
+async function fetchTeam(since) {
+    const res = await registryFetch(`/api/team${since ? `?since=${since}` : ""}`, { signal: AbortSignal.timeout(5_000) });
+    if (res.status === 304)
+        return null;
+    if (!res.ok)
+        throw new Error(`GET /api/team: HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    return (await res.json());
+}
+const recall = async ({ messages }) => {
+    try {
+        return await teamRecall(messages, fetchTeam);
+    }
+    catch (error) {
+        const note = error.message;
+        if (!warned.has(note)) {
+            warned.add(note);
+            console.warn(`team: ${note}`);
+        }
+        return { messages: [] };
+    }
+};
+export default defineMemory({
+    description: "The team: who is on it, what each bot can do, and who hands work to whom.",
+    namespace: "hub-team-memory",
+    scope: "workspace",
+    provider: defineMemoryProvider({
+        recall: { "turn.started": recall, "compaction.completed": recall },
+    }),
+});

package/mention-gate.mjs

@@ -20,11 +20,14 @@
 // overridden by HUB_MENTION_GATE (on|off), HUB_MENTION_GATE_MODEL,
 // HUB_MENTION_GATE_REASONING, HUB_MENTION_GATE_TIMEOUT_MS and
 // HUB_MENTION_GATE_URL (tests).
+import { codeRanges } from "./mention-tokens.mjs";
 import { registryHeaders } from "./registry-fetch.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 
+export { codeRanges };
+
 export const GATE_DEFAULTS = {
   enabled: true,
   model: "openai/gpt-6-luna-decisions",
@@ -194,69 +197,6 @@ export function triggerText(envelope) {
   return next < 0 ? rest : rest.slice(0, next);
 }
 
-// The character ranges of a message that are code, by CommonMark's rules:
-// fenced blocks (``` or ~~~, closed by the same character, at least as
-// long), and code spans (a run of n backticks closed by the next run of
-// exactly n on the same line; an opener can't be backslash-escaped).
-// Anything ambiguous stays text: an unclosed fence or an unmatched run is
-// literal, so a handle next to it counts as live.
-export function codeRanges(text) {
-  const s = String(text ?? "");
-  const ranges = [];
-  const lines = [];
-  for (let at = 0; at <= s.length; ) {
-    const nl = s.indexOf("\n", at);
-    const end = nl < 0 ? s.length : nl;
-    lines.push({ start: at, end, text: s.slice(at, end) });
-    if (nl < 0) break;
-    at = nl + 1;
-  }
-  // Fences first: only closed ones are code.
-  const fenced = new Set();
-  for (let i = 0; i < lines.length; i++) {
-    const open = lines[i].text.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
-    if (!open || (open[1][0] === "`" && open[2].includes("`"))) continue;
-    const close = new RegExp(`^ {0,3}${open[1][0] === "`" ? "`" : "~"}{${open[1].length},}\\s*$`);
-    const j = lines.findIndex((l, k) => k > i && close.test(l.text));
-    if (j < 0) continue;
-    ranges.push([lines[i].start, lines[j].end]);
-    for (let k = i; k <= j; k++) fenced.add(k);
-    i = j;
-  }
-  // Code spans.
-  let para = [];
-  const flush = () => {
-    if (!para.length) return;
-    const from = para[0].start;
-    const t = s.slice(from, para.at(-1).end);
-    const runs = [...t.matchAll(/`+/g)].map((m) => ({ at: m.index, n: m[0].length }));
-    for (let i = 0; i < runs.length; i++) {
-      let { at, n } = runs[i];
-      let slash = 0;
-      for (let b = at - 1; b >= 0 && t[b] === "\\"; b--) slash++;
-      if (slash % 2 === 1) {
-        // An escaped backtick is literal; the rest of the run can still open.
-        at++;
-        n--;
-        if (!n) continue;
-      }
-      const j = runs.findIndex((r, k) => k > i && r.n === n);
-      if (j < 0) continue;
-      ranges.push([from + at, from + runs[j].at + n]);
-      i = j;
-    }
-    para = [];
-  };
-  // One line at a time: a span that would cross lines might cross a block
-  // boundary (a heading or a list item interrupts a paragraph without a
-  // blank line), so it stays text.
-  lines.forEach((l, i) => {
-    if (!fenced.has(i) && l.text.trim()) para.push(l);
-    flush();
-  });
-  return ranges;
-}
-
 // Where the bot's @handle sits in a message, by parsing its markdown: in
 // code (codeRanges), on a > quote line, or live (anywhere else).
 export function mentionSites(text, agent) {

package/mention-tokens.mjs

@@ -1,4 +1,67 @@
-import { codeRanges } from "./mention-gate.mjs";
+// The mention rule: what counts as `@handle` in a message. No imports, so the
+// native editor checks load this one file as is.
+// The character ranges of a message that are code, by CommonMark's rules:
+// fenced blocks (``` or ~~~, closed by the same character, at least as
+// long), and code spans (a run of n backticks closed by the next run of
+// exactly n on the same line; an opener can't be backslash-escaped).
+// Anything ambiguous stays text: an unclosed fence or an unmatched run is
+// literal, so a handle next to it counts as live.
+export function codeRanges(text) {
+  const s = String(text ?? "");
+  const ranges = [];
+  const lines = [];
+  for (let at = 0; at <= s.length; ) {
+    const nl = s.indexOf("\n", at);
+    const end = nl < 0 ? s.length : nl;
+    lines.push({ start: at, end, text: s.slice(at, end) });
+    if (nl < 0) break;
+    at = nl + 1;
+  }
+  // Fences first: only closed ones are code.
+  const fenced = new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const open = lines[i].text.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    if (!open || (open[1][0] === "`" && open[2].includes("`"))) continue;
+    const close = new RegExp(`^ {0,3}${open[1][0] === "`" ? "`" : "~"}{${open[1].length},}\\s*$`);
+    const j = lines.findIndex((l, k) => k > i && close.test(l.text));
+    if (j < 0) continue;
+    ranges.push([lines[i].start, lines[j].end]);
+    for (let k = i; k <= j; k++) fenced.add(k);
+    i = j;
+  }
+  // Code spans.
+  let para = [];
+  const flush = () => {
+    if (!para.length) return;
+    const from = para[0].start;
+    const t = s.slice(from, para.at(-1).end);
+    const runs = [...t.matchAll(/`+/g)].map((m) => ({ at: m.index, n: m[0].length }));
+    for (let i = 0; i < runs.length; i++) {
+      let { at, n } = runs[i];
+      let slash = 0;
+      for (let b = at - 1; b >= 0 && t[b] === "\\"; b--) slash++;
+      if (slash % 2 === 1) {
+        // An escaped backtick is literal; the rest of the run can still open.
+        at++;
+        n--;
+        if (!n) continue;
+      }
+      const j = runs.findIndex((r, k) => k > i && r.n === n);
+      if (j < 0) continue;
+      ranges.push([from + at, from + runs[j].at + n]);
+      i = j;
+    }
+    para = [];
+  };
+  // One line at a time: a span that would cross lines might cross a block
+  // boundary (a heading or a list item interrupts a paragraph without a
+  // blank line), so it stays text.
+  lines.forEach((l, i) => {
+    if (!fenced.has(i) && l.text.trim()) para.push(l);
+    flush();
+  });
+  return ranges;
+}
 
 // The one definition of an actual mention: `@handle` at a word boundary (not
 // foo@bar, @@x, \@x or a URL's /@x) and outside code (codeRanges). Every reader of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.6.42",
+  "version": "0.6.44",
   "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/prepare.mjs

@@ -101,10 +101,10 @@ export default defineMemory({ namespace: ${JSON.stringify(`hub-${slot}-memory`)}
 // Replaces the kit's execution-context stub (the local page) with the hosted
 // page, for a bot the definition says is hosted. Its removed-tools list is read
 // from the bot's folder as pruned.
-function writeExecutionContext(bot, { bot: name, roster, deployment }) {
+function writeExecutionContext(bot, { bot: name, deployment }) {
   const kitTools = Object.keys(name === "main" ? MAIN_KIT_FILES : KIT_FILES).filter((file) => file.startsWith("tools/") && file !== "tools/bash.ts").map((file) => basename(file, ".ts"));
   const removed = kitTools.filter((tool) => !existsSync(join(bot, "tools", `${tool}.ts`)));
-  const section = hostedContext({ bot: name, roster, kit: KIT_VERSION, removed, deployment });
+  const section = hostedContext({ bot: name, kit: KIT_VERSION, removed, deployment });
   mkdirSync(join(bot, "instructions"), { recursive: true });
   writeFileSync(join(bot, "instructions", "execution-context.ts"), `import { defineInstructions } from "eve/instructions";\n\nexport default defineInstructions({ content: ${JSON.stringify(section)} });\n`);
 }
@@ -141,11 +141,10 @@ export function prepareDeployment(dir) {
       writeFileSync(join(bot, stub), content);
     }
   }
-  const roster = resolved.agents;
   const deployment = deploymentFacts();
   for (const name of readdirSync(join(dir, "agents"))) {
     const bot = join(dir, "agents", name, "agent");
-    writeExecutionContext(bot, { bot: name, roster, deployment });
+    writeExecutionContext(bot, { bot: name, deployment });
     // The kit's extension (kit__worker) runs host-only workers and is excluded from the kit tarball.
     // Other extensions, such as eve-code, stay.
     for (const item of readdirSync(bot, { recursive: true })) {

package/stubs.d.mts

@@ -1,6 +1,7 @@
 export const KIT_FILES: Record<string, string[]>;
 export const MAIN_KIT_FILES: Record<string, string[]>;
 export const DEPLOYED_KIT_FILES: Set<string>;
+export const MEMORY_STUBS: Record<string, string>;
 export const PROTOCOL_STUB_FILE: string;
 export const PROTOCOL_STUB: string;
 export function kitStub(file: string, options?: { files?: Record<string, string[]> }): string;

package/stubs.mjs

@@ -14,6 +14,7 @@ export const KIT_FILES = {
   "tools/update_thread.ts": ["Update a thread this bot is in: title, track, domain and summary."],
   "tools/list_threads.ts": ["Every workspace thread, from any session."],
   "tools/read_thread.ts": ["Read any workspace thread."],
+  "tools/list_agents.ts": ["The team right now: kind, place, tools, models, who's busy."],
   "tools/post_message.ts": ["Post into an existing thread or a bot's DM; with `status`, report the thread's phase."],
 };
 
@@ -28,7 +29,6 @@ export const MAIN_KIT_FILES = {
   "tools/move_path.ts": ["Rename or merge a path (project/track): every thread under it moves."],
   "tools/archive_thread.ts": ["Archive a thread whose work is done."],
   "tools/unarchive_thread.ts": ["Bring an archived thread back."],
-  "tools/list_agents.ts": ["The team right now: roles, models, who's busy."],
   "tools/create_agent.ts": ["Add a bot to the workspace."],
   "tools/remove_agent.ts": ["Remove a bot from the workspace."],
   "tools/restart_agent.ts": ["Restart one bot's server."],
@@ -61,6 +61,7 @@ export const DEPLOYED_KIT_FILES = new Set([
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",
   ...["react", "show", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),
+  "memory/team.ts",
   ...["create_thread", "set_summary", "move_path", "archive_thread", "unarchive_thread", "list_agents", "agent_send", "create_agent", "remove_agent", "restart_agent", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.ts`),
 ]);
 
@@ -97,9 +98,10 @@ import workspace from "../../../../hub.workspace.json" with { type: "json" };
 export default defineInstructions({ content: executionContext(${JSON.stringify(name)}, workspace) });
 `;
 
-// Every bot (main too) has two memory slots: memory/workspace.ts recalls the
-// workspace's memory/ entries and memory/bot.ts the bot's own
-// agents/<bot>/memory/ entries, every turn (packages/agent-kit/memory/).
+// Every bot (main too) has three memory slots: memory/workspace.ts recalls the
+// workspace's memory/ entries, memory/bot.ts the bot's own agents/<bot>/memory/
+// entries, and memory/team.ts the team model from the hub, every turn
+// (packages/agent-kit/memory/).
 const memoryStub = (slot, what) => `// ${what}, recalled every turn. From eve-hub
 // (packages/agent-kit/memory/${slot}.ts); add or supersede entries there, not here.
 export { default } from "eve-hub/memory/${slot}";
@@ -107,6 +109,7 @@ export { default } from "eve-hub/memory/${slot}";
 export const MEMORY_STUBS = {
   "memory/workspace.ts": memoryStub("workspace", "The workspace's memory/ entries"),
   "memory/bot.ts": memoryStub("bot", "This bot's own agents/<bot>/memory/ entries"),
+  "memory/team.ts": memoryStub("team", "The team model (roster, tools, handoffs) from the hub"),
 };
 
 // main's instructions aren't copied into a workspace: agent/instructions.ts

package/sync-kit.mjs

@@ -65,8 +65,8 @@ export function syncKit({ bots, modules }) {
     const wanted = new Set(Object.keys(stubs).filter((file) => local || DEPLOYED_KIT_FILES.has(file)));
     if (local) {
       wanted.add(EXECUTION_CONTEXT_STUB_FILE);
-      for (const file of Object.keys(MEMORY_STUBS)) wanted.add(file);
     }
+    for (const file of Object.keys(MEMORY_STUBS)) if (local || DEPLOYED_KIT_FILES.has(file)) wanted.add(file);
     const content = (file) => (file === EXECUTION_CONTEXT_STUB_FILE ? executionContextStub(bot) : MEMORY_STUBS[file] ?? kitStub(file, { files: stubs }));
     for (const file of Object.keys(files).sort()) {
       const rel = file.replace(SUBAGENT, "");

package/team.d.mts

@@ -0,0 +1,24 @@
+export type TeamNode = {
+  id: string;
+  kind: "human" | "coordinator" | "planner" | "builder" | "reviewer" | "git-ops" | "demo" | "other";
+  label: string;
+  color?: string;
+  role?: string;
+  model?: string;
+  runsOn?: "hosted" | "local";
+  tools?: string[] | null;
+  subagents?: string[];
+};
+export type TeamEdge = { from: string; to: string; kind: string };
+export type TeamModel = { version: 1; hash: string; nodes: TeamNode[]; edges: TeamEdge[] };
+export type TeamAgent = { name: string; role: string; model: string; color?: string; kind?: string; runsOn?: "hosted" | "local"; subagents?: Record<string, unknown> };
+export const KINDS: readonly string[];
+export const MODEL_VERSION: 1;
+export const NODE_KINDS: readonly [string, ...string[]];
+export const EDGE_KINDS: readonly [string, ...string[]];
+export const SECTIONS: readonly { id: string; edge: { kind: string; from: unknown; to: unknown }; text: string }[];
+export const SECTIONS_HASH: string;
+export function teamEdges(nodes: readonly TeamNode[]): TeamEdge[];
+export function teamModel(input: { agents: readonly TeamAgent[]; humans?: readonly { name: string; color?: string }[]; tools?: Record<string, readonly string[] | null | undefined> }): TeamModel;
+export function teamText(model: TeamModel): string;
+export function teamRecall(history: readonly unknown[], fetchTeam: (since?: string) => Promise<TeamModel | null>): Promise<{ messages: { id: string; content: string }[] }>;

package/team.mjs

@@ -0,0 +1,113 @@
+// The team model: who is on the team, what each bot can do, and who hands work
+// to whom. One derivation feeds every reader: the hub's GET /api/team (the
+// native Team window, list_agents) and the prompt's team slot (memory/team.ts),
+// which delivers it to a session once and again only when it changes.
+//
+// A bot's `kind` is its place in the team (hub.workspace.json). Its tools are
+// what its running eve reports (/v1/info), never read from files. The edges
+// come from SECTIONS: each protocol section names the edge it draws between
+// kinds (or a tool), and the same entry renders the sentence the bots read.
+import { createHash } from "node:crypto";
+import { KINDS } from "./workspace.mjs";
+
+export { KINDS };
+export const MODEL_VERSION = 1;
+export const NODE_KINDS = [...KINDS, "other", "human"];
+
+const sha = (text, length) => createHash("sha256").update(text).digest("hex").slice(0, length);
+
+// Selectors: "human", "bots" (every bot), { kind: [...] } or { tool: "agent_send" };
+// all but the first pick bots. `text` is the sentence the team prompt carries when the section
+// has at least one edge; `{from}` is the names behind the edge's from side.
+export const SECTIONS = [
+  { id: "partner", edge: { kind: "partner", from: "human", to: { kind: ["coordinator"] } }, text: "The coordinator works with the human directly." },
+  { id: "route", edge: { kind: "route", from: { kind: ["coordinator"] }, to: { kind: ["planner", "builder"] } }, text: "The coordinator routes work to planners and builders." },
+  { id: "plan", edge: { kind: "plan", from: { kind: ["planner"] }, to: { kind: ["builder"] } }, text: "Planners hand plans to builders." },
+  { id: "build", edge: { kind: "build", from: { kind: ["builder"] }, to: { kind: ["reviewer"] } }, text: "Builders hand finished work to a reviewer." },
+  { id: "fixfirst", edge: { kind: "fixfirst", from: { kind: ["reviewer"] }, to: { kind: ["builder"] } }, text: "Reviewers send fixes back to the builder that posted the build." },
+  { id: "ship", edge: { kind: "ship", from: { kind: ["reviewer"] }, to: "human" }, text: "A reviewer's ship verdict goes to the human." },
+  { id: "escalate", edge: { kind: "escalate", from: { kind: ["git-ops"] }, to: { kind: ["builder"] } }, text: "Git-ops bots report what they can't fix to a builder." },
+  { id: "steer", edge: { kind: "steer", from: { tool: "agent_send" }, to: "bots" }, text: "Only {from} can queue work for or steer another bot (`agent_send`)." },
+];
+export const EDGE_KINDS = SECTIONS.map((section) => section.edge.kind);
+export const SECTIONS_HASH = sha(JSON.stringify(SECTIONS), 8);
+
+const pick = (selector, nodes) =>
+  nodes.filter((n) => {
+    if (selector === "human") return n.kind === "human";
+    if (n.kind === "human") return false;
+    return selector === "bots" || (selector.kind ? selector.kind.includes(n.kind) : Boolean(n.tools?.includes(selector.tool)));
+  });
+
+export function teamEdges(nodes) {
+  const edges = [];
+  for (const { edge } of SECTIONS) {
+    const from = pick(edge.from, nodes);
+    const to = pick(edge.to, nodes);
+    for (const f of from) for (const t of to) if (f.id !== t.id) edges.push({ from: f.id, to: t.id, kind: edge.kind });
+  }
+  return edges;
+}
+
+// `agents`: hub.workspace.json's agents plus `runsOn` resolved; `tools`: bot
+// name -> the tool names its eve reports, absent or null when not reported.
+export function teamModel({ agents, humans = [], tools = {} }) {
+  const nodes = [
+    ...humans.map((h) => ({ id: h.name, kind: "human", label: h.name, ...(h.color ? { color: h.color } : {}) })),
+    ...agents.map((a) => ({
+      id: a.name,
+      kind: a.kind ?? "other",
+      label: a.name,
+      ...(a.color ? { color: a.color } : {}),
+      role: a.role,
+      model: a.model,
+      runsOn: a.runsOn ?? "hosted",
+      tools: tools[a.name] ? [...new Set(tools[a.name])].sort() : null,
+      subagents: Object.keys(a.subagents ?? {}),
+    })),
+  ];
+  const edges = teamEdges(nodes);
+  return { version: MODEL_VERSION, hash: sha(JSON.stringify({ nodes, edges }), 12), nodes, edges };
+}
+
+const list = (items) => items.join(", ");
+
+// What a session reads: the roster with each bot's kind, place and tools, then
+// the handoff sentences. Identical for every bot, so one slot text serves the
+// whole team. The header carries both hashes: the model's and the sections'.
+export function teamText(model) {
+  const bots = model.nodes.filter((n) => n.kind !== "human");
+  const reported = bots.filter((b) => b.tools);
+  const shared = reported.length ? reported[0].tools.filter((t) => reported.every((b) => b.tools.includes(t))) : [];
+  const lines = [`Team model ${model.hash}/${SECTIONS_HASH}: the team right now, from the hub. It replaces any earlier team model above.`, "", "Bots:"];
+  for (const b of bots) {
+    const own = b.tools?.filter((t) => !shared.includes(t));
+    const where = b.runsOn === "local" ? "on the owner's Mac" : "on Vercel";
+    lines.push(`- ${b.id} (${b.kind}, ${where}): ${b.role}${own?.length ? ` Also: ${list(own)}.` : ""}${b.tools ? "" : " Tools not reported."}${b.subagents.length ? ` Subagents: ${list(b.subagents)}.` : ""}`);
+  }
+  if (shared.length) lines.push("", `Every bot with reported tools has: ${list(shared)}.`);
+  const rules = SECTIONS.flatMap(({ id, edge, text }) => {
+    const from = model.edges.filter((e) => e.kind === edge.kind).map((e) => e.from);
+    return from.length ? [`- ${text.replace("{from}", list([...new Set(from)]))}`] : [];
+  });
+  if (rules.length) lines.push("", "Handoffs:", ...rules);
+  return lines.join("\n");
+}
+
+const textOf = (m) => (typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => (p?.type === "text" ? p.text : "")).join("") : "");
+const HEADER = /^Team model ([0-9a-f]{12})\/([0-9a-f]{8}):/;
+
+// The team slot's recall, given the session's history: the team model as one
+// message when it differs from the last one this session was given, nothing
+// otherwise. `fetchTeam(since)` asks the hub, with the model hash the session
+// holds (only while these sections are the ones that rendered it), and answers
+// the model, or null when the hub says nothing changed.
+export async function teamRecall(history, fetchTeam) {
+  const given = history.filter((m) => m?.role === "user" && m.kind === "memory.load" && HEADER.test(textOf(m))).map(textOf);
+  const last = HEADER.exec(given.at(-1) ?? "");
+  const model = await fetchTeam(last && last[2] === SECTIONS_HASH ? last[1] : undefined);
+  if (!model) return { messages: [] };
+  const text = teamText(model);
+  if (given.at(-1) === text) return { messages: [] };
+  return { messages: [{ id: `team#${given.length + 1}@${sha(text, 8)}`, content: text }] };
+}

package/tools/list_agents.d.ts

@@ -2,6 +2,9 @@ declare const _default: import("eve/tools").ToolDefinition<Record<string, never>
     name: string;
     role: string;
     model: string;
+    kind?: string;
+    runsOn?: "hosted" | "local";
+    tools?: string[] | null;
     subagentCap: string;
     subagents: Array<{
         name: string;
@@ -31,6 +34,9 @@ declare const _default: import("eve/tools").ToolDefinition<Record<string, never>
         name: string;
         role: string;
         model: string;
+        kind?: string;
+        runsOn?: "hosted" | "local";
+        tools?: string[] | null;
         subagentCap: string;
         subagents: Array<{
             name: string;

package/tools/list_agents.js

@@ -2,7 +2,7 @@ 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; 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.",
+    description: "List the workspace's bots right now: each one's role, kind (its place in the team: coordinator, planner, builder, reviewer, git-ops, demo, or other), where it runs (hosted or local), the tools its runtime reports (null when not yet reported), its 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() {
         // Anything but a 2xx list of bots is an error naming the status and the

package/workspace.mjs

@@ -47,9 +47,11 @@ export const DOMAIN = /^[a-z][a-z0-9-]*(\/[a-z][a-z0-9-]*)*$/;
 export const NAME = /^[a-z][a-z0-9-]{1,30}$/;
 export const HUMAN_NAME = /^[a-z][a-z0-9-]{0,30}$/;
 const COLOR = /^#[0-9a-f]{3}([0-9a-f]{3})?$/i;
-const AGENT_KEYS = new Set(["name", "model", "role", "color", "subagents", "subagentCap", "limits", "port", "runsOn", "domains"]);
+const AGENT_KEYS = new Set(["name", "model", "role", "color", "subagents", "subagentCap", "limits", "port", "runsOn", "domains", "kind"]);
 
 export const RUNS_ON = ["hosted", "local"];
+// The bot's place in the team (team.mjs draws the handoffs between kinds).
+export const KINDS = ["coordinator", "planner", "builder", "reviewer", "git-ops", "demo"];
 
 export class WorkspaceError extends Error {}
 
@@ -102,6 +104,7 @@ export function parseWorkspace(data, file = WORKSPACE_FILE) {
     // Where the bot runs: on the hosted bots project (default), or on the human's Mac, started by
     // the app's local runner. Fixed at definition.
     if (agent.runsOn !== undefined && !RUNS_ON.includes(agent.runsOn)) fail(file, `${label}.runsOn must be "hosted" or "local"`);
+    if (agent.kind !== undefined && !KINDS.includes(agent.kind)) fail(file, `${label}.kind must be one of ${KINDS.join(", ")}`);
     if (agent.domains !== undefined && (!Array.isArray(agent.domains) || agent.domains.some((d) => typeof d !== "string" || !DOMAIN.test(d)))) fail(file, `${label}.domains must be an array of memory folders like "ui" or "ui/motion"`);
     const unknown = Object.keys(agent).filter((k) => !AGENT_KEYS.has(k));
     if (unknown.length) fail(file, `${label}: unknown field(s) ${unknown.join(", ")}`);