eve-hub 0.16.18 → 0.16.20

package/bash-run.mjs

@@ -10,7 +10,7 @@ import { lstatSync, readlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { hubSelfStopVerb, selfStopMessage, stripHeredocs } from "./self-restart.mjs";
-import { readWorkspaceFile } from "./workspace.mjs";
+import { coordinatorOf, readWorkspaceFile } from "./workspace.mjs";
 
 export const DEFAULT_TIMEOUT_S = 180;
 export const MAX_TIMEOUT_S = 1800;
@@ -231,12 +231,15 @@ export function linkedInstallTargets(command, cwd) {
 
 // `sandbox`: an eve SandboxSession (spawn -> { stdout, stderr, wait, kill }).
 // `hub stop` / `hub restart` from a bot's own shell (the daemon sets HUB_AGENT
-// for every bot) takes down the bot running it (self-restart.mjs); main uses
+// for every bot) takes down the bot running it (self-restart.mjs); the coordinator uses
 // its restart_hub tool instead.
 export function selfStopRefusal(command, env = process.env) {
   if (!env.HUB_AGENT) return null;
   const verb = hubSelfStopVerb(maskQuoted(stripHeredocs(command)));
-  return verb ? `[${selfStopMessage(verb, env.HUB_AGENT)}]` : null;
+  if (!verb) return null;
+  const root = env.HUB_WORKSPACE?.trim() || env.HUB_ROOT?.trim();
+  if (!root) throw new Error("HUB_AGENT is set without HUB_WORKSPACE or HUB_ROOT, so the coordinator can't be read");
+  return `[${selfStopMessage(verb, env.HUB_AGENT, coordinatorOf(readWorkspaceFile(resolve(root)).agents))}]`;
 }
 
 /**

package/execution-context.mjs

@@ -10,7 +10,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { section, templatesDir } from "./main-instructions.mjs";
-import { agentRunsOn, parseWorkspace } from "./workspace.mjs";
+import { agentRunsOn, coordinatorOf, parseWorkspace } from "./workspace.mjs";
 
 const page = (name, options) => readFileSync(join(templatesDir(options), `execution-context-${name}.md`), "utf8").trimEnd();
 
@@ -40,7 +40,7 @@ export function deploymentFacts(env = process.env) {
 
 const list = (items) => items.map((item) => `\`${item}\``).join(", ");
 
-export function hostedContext({ bot, kit, removed, deployment: d, git = false }, options) {
+export function hostedContext({ bot, coordinator, kit, removed, deployment: d, git = false }, options) {
   const dashboard = d.team && d.project ? `https://vercel.com/${d.team}/${d.project}` : undefined;
   const lines = [
     `You are \`${bot}\`, an eve agent deployed on Vercel, not on a laptop: \`hub.workspace.json\` defines you as hosted.`,
@@ -65,7 +65,7 @@ export function hostedContext({ bot, kit, removed, deployment: d, git = false },
     "- **Limits:** there is no `hub` CLI, you cannot restart yourself or any bot, and there are no host paths: your shell is a Vercel Sandbox with its own filesystem, not the owner's machine.",
     `- **Kit tools this build removed:** ${removed.length ? list(removed) : "none"}. They need the hub's machine, or change the roster, which a deployment does by commit.`,
     `- **Logs:** ${dashboard ? `[runtime logs](${dashboard}/logs)${d.deployment ? ` and [this deployment](${dashboard}/${d.deployment.replace(/^dpl_/, "")})` : ""} in the Vercel dashboard` : "the Vercel project's runtime logs in the dashboard"}.`,
-    ...(bot === "main" ? [page("hosted-main", options)] : []),
+    ...(coordinator ? [page("hosted-main", options)] : []),
   ];
   return `${section("execution_context", lines.join("\n"))}\n`;
 }
@@ -78,6 +78,6 @@ export function executionContext(bot, workspace, options) {
   if (runsOn !== "local") {
     throw new Error(`${bot} is defined as hosted in hub.workspace.json, and a hosted bot's execution context is written by its Vercel build (eve-hub/vercel). A bot on this machine needs "runsOn": "local", on the agent or at the top of hub.workspace.json.`);
   }
-  const lines = [`You are \`${bot}\`: \`hub.workspace.json\` defines you as local.`, "", page("local", options), ...(bot === "main" ? [page("local-main", options)] : [])];
+  const lines = [`You are \`${bot}\`: \`hub.workspace.json\` defines you as local.`, "", page("local", options), ...(coordinatorOf(parsed.agents) === bot ? [page("local-main", options)] : [])];
   return `${section("execution_context", lines.join("\n"))}\n`;
 }

package/kit-change.mjs

@@ -4,7 +4,7 @@
 // `git__gh` runs in (migrateSandbox). Customized files are left alone and reported.
 import { isKitFile, syncKit } from "./sync-kit.mjs";
 import { migrateSandbox } from "./sandbox-migrate.mjs";
-import { agentRunsOn, parseWorkspace, WorkspaceError, WORKSPACE_FILE } from "./workspace.mjs";
+import { agentRunsOn, coordinatorOf, parseWorkspace, WorkspaceError, WORKSPACE_FILE } from "./workspace.mjs";
 import KIT_MODULES from "./kit-modules.json" with { type: "json" };
 
 const AGENT_FILE = /^agents\/([^/]+)\/agent\/(.+)$/;
@@ -37,7 +37,7 @@ export async function kitChange({ paths, read }) {
   }
   const tiersOf = (name) => Object.keys(definition.agents.find((a) => a.name === name)?.subagents ?? {});
   const bots = [...files].map(([name, f]) => ({ name, runsOn: agentRunsOn(definition, name), files: f, subagents: tiersOf(name) }));
-  const change = syncKit({ bots, modules: KIT_MODULES });
+  const change = syncKit({ bots, modules: KIT_MODULES, coordinator: coordinatorOf(definition.agents) });
   const path = (bot, file) => `agents/${bot}/agent/${file}`;
   const world = agentFiles.filter((f) => f.text.includes("eve-hub/world")).map((f) => ({ path: f.path, text: f.text.replace(HUB_WORLD_LINE, "") }));
   const moved = sandboxes.map((f) => ({ path: f.path, text: f.text, ...migrateSandbox(f.text) }));

package/main-instructions.mjs

@@ -12,7 +12,7 @@ import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ROLE_DIR, ROLE_FILE } from "./role-files.mjs";
-import { WorkspaceError, findWorkspaceRoot } from "./workspace.mjs";
+import { WorkspaceError, coordinatorOf, findWorkspaceRoot, readWorkspaceFile } from "./workspace.mjs";
 
 const HEAD = "main-instructions.md";
 const ENGINEERING = "engineering.md";
@@ -58,6 +58,7 @@ const assemble = ({ identity, role }, additions, shared, options) =>
 // A bot's own additions to its role: agents/<bot>/agent/role/*.md, by file name, inside <role>.
 // They can't sit in instructions/*.md: eve loads that folder itself, after execution-context.ts,
 // outside every tag. A workspace with no folder (or no workspace at all) has none.
+// `bot` null: the workspace's coordinator, whatever its name.
 function additionsOf(bot, options) {
   let root;
   try {
@@ -66,6 +67,8 @@ function additionsOf(bot, options) {
     if (error instanceof WorkspaceError) return [];
     throw error;
   }
+  bot ??= coordinatorOf(readWorkspaceFile(root).agents);
+  if (!bot) return [];
   const dir = join(root, "agents", bot, "agent", ROLE_DIR);
   if (!existsSync(dir)) return [];
   return readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((f) => readFileSync(join(dir, f), "utf8").trim());
@@ -73,7 +76,7 @@ function additionsOf(bot, options) {
 
 // Main never builds, so it goes without <engineering>.
 const MAIN_SHARED = SHARED.filter(([tag]) => tag !== ENGINEERING.slice(0, -3));
-export const mainInstructions = (options) => assemble(splitRole(template(HEAD, options), HEAD), additionsOf("main", options), MAIN_SHARED, options);
+export const mainInstructions = (options) => assemble(splitRole(template(HEAD, options), HEAD), additionsOf(null, options), MAIN_SHARED, options);
 
 // Every other bot: agents/<bot>/agent/role.md in the workspace.
 export { ROLE_DIR, ROLE_FILE };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.18",
+  "version": "0.16.20",
   "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

@@ -25,7 +25,7 @@ import { applyKit, readBotFiles, syncKit } from "./sync-kit.mjs";
 export { DEPLOYED_KIT_FILES };
 import { deploymentFacts, hostedContext } from "./execution-context.mjs";
 import { activeEntries, botDomains, domainFolders, entryText, readBotMemory, readMemory, validateMemory } from "./memory.mjs";
-import { agentRunsOn, readWorkspaceFile, removeWorkspaceAgent } from "./workspace.mjs";
+import { agentRunsOn, coordinatorOf, readWorkspaceFile, removeWorkspaceAgent } from "./workspace.mjs";
 import { architectureText } from "./team.mjs";
 import { sandboxReady } from "./sandbox-migrate.mjs";
 import { GITHUB_CONNECTOR } from "./github-connector.mjs";
@@ -178,10 +178,10 @@ export default dashSchedule({ decisions: () => decisions });
 // 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, 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"));
+function writeExecutionContext(bot, { bot: name, coordinator, deployment }) {
+  const kitTools = Object.keys(coordinator ? 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, kit: KIT_VERSION, removed, deployment, git: existsSync(join(bot, GIT_EXTENSION_FILE)) });
+  const section = hostedContext({ bot: name, coordinator, kit: KIT_VERSION, removed, deployment, git: existsSync(join(bot, GIT_EXTENSION_FILE)) });
   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`);
 }
@@ -193,12 +193,13 @@ export function prepareDeployment(dir) {
   if (existsSync(join(dir, MANIFEST_FILE))) return;
   validateMemory(dir);
   const definition = readWorkspaceFile(dir);
+  const coordinator = coordinatorOf(definition.agents);
   const resolved = { ...definition, agents: definition.agents.map((agent) => ({ ...agent, runsOn: agentRunsOn(definition, agent.name) })) };
   const dirOf = (name) => join(dir, "agents", name, "agent");
   const local = new Set(resolved.agents.filter((a) => a.runsOn === "local").map((a) => a.name));
   const folders = readdirSync(join(dir, "agents")).filter((name) => !local.has(name) && existsSync(join(dirOf(name), "agent.ts")));
   const tiersOf = (name) => Object.keys(definition.agents.find((a) => a.name === name)?.subagents ?? {});
-  const change = syncKit({ bots: folders.map((name) => ({ name, runsOn: "hosted", files: readBotFiles(dirOf(name)), subagents: tiersOf(name) })), modules: KIT_MODULES });
+  const change = syncKit({ bots: folders.map((name) => ({ name, runsOn: "hosted", files: readBotFiles(dirOf(name)), subagents: tiersOf(name) })), modules: KIT_MODULES, coordinator });
   if (change.report.length) throw new Error(`these files can't ship to a hosted deployment; update or delete them:\n${change.report.map((r) => `  agents/${r.bot}/agent/${r.file} ${r.reason}`).join("\n")}`);
   const deployment = deploymentFacts();
   // The git extension's `git__gh` runs eve-code's gh; a sandbox an earlier template wrote has none. The hub's kit update moves it (sandbox-migrate.mjs).
@@ -210,8 +211,8 @@ export function prepareDeployment(dir) {
     removeWorkspaceAgent(dir, name);
     rmSync(join(dir, "agents", name), { recursive: true, force: true });
   }
-  mkdirSync(join(dir, "agents", "main", "agent", "channels"), { recursive: true });
-  writeFileSync(join(dir, "agents", "main", "agent", "channels", "manifest.ts"), MANIFEST_CHANNEL);
+  mkdirSync(join(dirOf(coordinator), "channels"), { recursive: true });
+  writeFileSync(join(dirOf(coordinator), "channels", "manifest.ts"), MANIFEST_CHANNEL);
   applyKit(change, dirOf);
   // Bots only: a declared subagent's agent.ts (agent/subagents/<tier>/) is not a bot and mounts none of these.
   for (const name of readdirSync(join(dir, "agents"))) {
@@ -230,7 +231,7 @@ export function prepareDeployment(dir) {
   }
   for (const name of readdirSync(join(dir, "agents"))) {
     const bot = join(dir, "agents", name, "agent");
-    writeExecutionContext(bot, { bot: name, deployment });
+    writeExecutionContext(bot, { bot: name, coordinator: name === coordinator, deployment });
     // The kit's extension mounts only on the hub's machine and is excluded from the kit tarball.
     // Other extensions, such as eve-code, stay.
     for (const item of readdirSync(bot, { recursive: true })) {
@@ -244,7 +245,7 @@ export function prepareDeployment(dir) {
     const botDir = join(dir, "agents", name);
     const { entries } = readMemory(dir, { folders: domainFolders(botDomains(dir, botDir)) });
     writeFileSync(join(bot, "memory", "workspace.ts"), memoryProvider("workspace", entries, "Standing decision", "workspace"));
-    if (name === "main" && isKitDashSchedule(bot)) writeFileSync(join(bot, DASH_SCHEDULE_FILE), dashScheduleStub(entries));
+    if (name === coordinator && isKitDashSchedule(bot)) writeFileSync(join(bot, DASH_SCHEDULE_FILE), dashScheduleStub(entries));
     // A folder the roster doesn't list has no place in the team, and a function can't read the file the stub would.
     if (definition.agents.some((a) => a.name === name)) writeFileSync(join(bot, "memory", "team.ts"), teamProvider(architectureText(definition.data, name)));
     else rmSync(join(bot, "memory", "team.ts"), { force: true });

package/schedules/dash-classify.mjs

@@ -28,6 +28,7 @@
 // tests (plain node) import the same module.
 
 import { createHash } from "node:crypto";
+import { coordinatorOf } from "../workspace.mjs";
 import { lastSaid, said, threadBrief, briefText } from "./thread-brief.mjs";
 import { busyBasis, factsText, laneFacts, factsKey, paragraphs, reasonLine } from "./lane-facts.mjs";
 
@@ -69,7 +70,7 @@ export function pathsInProject(t, snap) {
 export function pathQuestion(paths) {
   if (!paths.length) return null;
   const criteria = Object.fromEntries(paths.map((u) => [u.id, `Path ${u.id}: "${u.title}". ${u.summary} Open threads: ${u.count}.`]));
-  criteria[NEW_PATH] = "No listed path fits this work, even read broadly; main must name a new path.";
+  criteria[NEW_PATH] = "No listed path fits this work, even read broadly; the coordinator must name a new path.";
   return { type: "choice", instructions: "Which path covers this thread's work? Paths group threads by feature or effort at any depth. A bug, polish or follow-up belongs to its area's existing path. Prefer an existing path where it fits; choose new only when none fits.", criteria };
 }
 
@@ -230,7 +231,7 @@ export function newPathNotice(threads, snap) {
   for (const t of threads) byProject.set(t.tags?.project ?? "", [...(byProject.get(t.tags?.project ?? "") ?? []), t]);
   const brief = (t) => [`- ${t.id}`, ...briefText(threadBrief(t, snap)).split("\n").map((l) => `  ${l}`)];
   return [
-    `@main, these are every unfiled thread in each project. Group each project's work in one go from its briefs, using read_thread when needed. Put each thread on a listed path where one fits, or on a new project/feature path, with update_thread (threadId and path only, including threads you aren't in). Merge near-duplicate paths with move_path. Never move a human-locked path.`,
+    `@${coordinatorOf(snap?.agents)}, these are every unfiled thread in each project. Group each project's work in one go from its briefs, using read_thread when needed. Put each thread on a listed path where one fits, or on a new project/feature path, with update_thread (threadId and path only, including threads you aren't in). Merge near-duplicate paths with move_path. Never move a human-locked path.`,
     ...[...byProject].flatMap(([p, ts]) => {
       const paths = pathsInProject(ts[0], snap);
       return [
@@ -253,14 +254,14 @@ const asking = (lane) => lane === "needs-you" || lane === "ready";
 // it in one write (hub.dashEntries), so a verdict and its notice are kept
 // together or not at all, and a failed write is judged afresh next pass
 // against the entry as it still is.
-export function asksNotice(e, t) {
+export function asksNotice(e, t, coordinator) {
   const was = t.entry?.lane;
   if (was === e.lane || (asking(was) && asking(e.lane))) return null;
   const link = `[${String(t.title ?? t.id).replace(/[[\]]/g, "")}](${t.id})`;
   const line = asking(e.lane) ? `needs you: ${link}, ${e.reason}` : asking(was) ? `no longer asking you: ${link}` : null;
   if (!line) return null;
   const key = `asks-${createHash("sha256").update(`${e.threadId}:${e.lane}:${e.basis}`).digest("hex").slice(0, 32)}`;
-  return { schedule: "dash", text: `@main dash: ${line}`, clientId: key };
+  return { schedule: "dash", text: `@${coordinator} dash: ${line}`, clientId: key };
 }
 
 // The `new` answers of a pass go to main in one notice per project (deduped
@@ -313,7 +314,7 @@ export async function runClassify(hub, { classify = async () => null, max = CLAS
     if (d.path) picks.push([t, d.path]);
     const own = humans.has(t.entry?.importanceBy);
     const entry = { threadId: t.id, ...(own || d.importance === undefined ? {} : { importance: d.importance }), lane: d.lane, reason: d.reason, basis: t.basis };
-    const notice = asksNotice(entry, t);
+    const notice = asksNotice(entry, t, coordinatorOf(s?.agents));
     try {
       await (notice ? hub.dashEntries([entry], [], notice) : hub.dashEntries([entry]));
       return 1;

package/schedules/dash-plan.mjs

@@ -201,7 +201,7 @@ export function planPrompt(cards, about, { human = "me", prev = null, now = Date
   const open = new Set(cards.map((c) => c.id));
   const was = prev ? [...prev.chunks.flatMap((c) => c.rows.map((r) => ({ id: r.id, chunk: c.title }))), ...(prev.later?.rows ?? []).map((r) => ({ id: r.id, chunk: "later" }))].filter((r) => open.has(r.id)) : null;
   return [
-    `You are main, ${human}'s chief of staff, triaging ${human}'s open threads by hand, exactly as ${human} would if they read every one in full. The cards below are threads where a bot said something after ${human}'s last message.`,
+    `You are the coordinator, ${human}'s chief of staff, triaging ${human}'s open threads by hand, exactly as ${human} would if they read every one in full. The cards below are threads where a bot said something after ${human}'s last message.`,
     `For each card decide: is something actually waiting on ${human} (a question, a decision, an approval, a look, a sign-off only they can give), or not (a status report, a bot-to-bot handoff, already settled, or waiting on someone else)? Judge from the text of the ask, not from tags.`,
     `Then order every real ask the way a careful person would work through them, as a chief of staff briefing ${human}: one chunk per track, so ${human} switches context as little as possible. Each card's \`context\` is its track and repo. Put first what matters most and what is blocking others; weigh how taxing each one is (how much to read, diff size, how many decisions). The rule: never come back to a track. All asks of one track sit in its one chunk, or all in "later"; within a track, put quick yeses first and deep reads last. The track of the thread they answered last (justAnswered) goes first, and that thread, if something waits there, is its first row: the share of their messages that stay in the previous message's thread is in the facts. A track whose asks can wait goes to "later" as a whole, not a piece of it. Quick yeses that unblock bots go early.`,
     was ? [`The previous plan, in order (move a row only when a fact changed, and say why in "moved"):`, ...was.map((r) => `- ${r.id} (${r.chunk})`)].join("\n") : "There is no previous plan: \"moved\" is empty.",

package/schedules/dash-rules.mjs

@@ -11,6 +11,7 @@ const parse = (iso) => {
 };
 const link = (thread) => `[${String(thread?.title ?? thread?.id ?? "?").replace(/[[\]]/g, "")}](${thread?.id})`;
 import { said, lastSaid } from "./thread-brief.mjs";
+import { coordinatorOf } from "../workspace.mjs";
 
 // ---------------------------------------------------------------------------
 // dash: what changed since the last scan that could put something on the
@@ -180,7 +181,8 @@ function waitMet(item, snap, prs, nowMs) {
   if (w.thread) {
     const t = snap?.threads?.[w.thread];
     const since = parse(w.since) ?? 0;
-    const m = t && [...(t.messages ?? [])].reverse().find((x) => said(x) && x.author !== "main" && (parse(x.at) ?? 0) > since);
+    const coordinator = coordinatorOf(snap?.agents);
+    const m = t && [...(t.messages ?? [])].reverse().find((x) => said(x) && x.author !== coordinator && (parse(x.at) ?? 0) > since);
     if (m) return `${link(t)} got a message from ${m.author}`;
   }
   if (w.until && (parse(w.until) ?? Infinity) <= nowMs) return `${w.until.slice(0, 16).replace("T", " ")} passed`;
@@ -207,6 +209,7 @@ export function dashScan(snap, saved, prs, nowMs, hashOf, skip = new Set()) {
   const lines = [...pr.lines];
   const threads = snap?.threads ?? {};
   const items = snap?.dash?.items ?? [];
+  const coordinator = coordinatorOf(snap?.agents);
   const legacy = saved && saved.na !== undefined; // the short-lived time-based form: start over
 
   // Asks, by identity. A thread a bot is working in keeps its previous entry
@@ -243,11 +246,11 @@ export function dashScan(snap, saved, prs, nowMs, hashOf, skip = new Set()) {
     if (!t) continue;
     const working = Object.values(t.status ?? {}).includes("working");
     let was = legacy ? undefined : saved?.d?.[item.threadId];
-    // An item new since the last scan: its baseline is the thread as main
-    // saw it when adding it, so anything said since (by anyone but main) counts.
+    // An item new since the last scan: its baseline is the thread as the coordinator
+    // saw it when adding it, so anything said since (by anyone else) counts.
     if (was === undefined && saved && item.addedAt) {
       const since = parse(item.addedAt) ?? Infinity;
-      was = (t.messages ?? []).some((x) => said(x) && x.author !== "main" && (parse(x.at) ?? 0) > since) ? "~" : undefined;
+      was = (t.messages ?? []).some((x) => said(x) && x.author !== coordinator && (parse(x.at) ?? 0) > since) ? "~" : undefined;
     }
     // Working: judged once it settles. A thread first seen working is marked
     // "~", so its first settled message counts as moving on.
@@ -259,7 +262,7 @@ export function dashScan(snap, saved, prs, nowMs, hashOf, skip = new Set()) {
     d[item.threadId] = t.archived ? "archived" : (m?.id ?? "-");
     if (was === undefined || was === d[item.threadId]) continue;
     if (t.archived) lines.push(`archived: ${link(t)} is still on the Dash`);
-    else if (m && !askingNow.has(item.threadId) && !noLonger.has(item.threadId) && m.author !== "main") lines.push(`moved on: ${link(t)} (${item.ball}), ${m.author}: "${excerpt(m.text, 80)}"`);
+    else if (m && !askingNow.has(item.threadId) && !noLonger.has(item.threadId) && m.author !== coordinator) lines.push(`moved on: ${link(t)} (${item.ball}), ${m.author}: "${excerpt(m.text, 80)}"`);
   }
 
   const w = {};

package/schedules/dash-run.mjs

@@ -19,6 +19,7 @@ import { createHash } from "node:crypto";
 import { NoValidTokenError, UserAuthorizationRequiredError, getToken } from "@vercel/connect";
 import { GITHUB_CONNECTOR, rosterSubject } from "../github-connector.mjs";
 import { runOnce } from "./hub.mjs";
+import { coordinatorOf } from "../workspace.mjs";
 import { REFS_PER_QUERY, dashPrs, dashQuery, dashScan, dashWatchList, failedRefs, prsFromSearch } from "./dash-rules.mjs";
 
 // The hub gives a schedule 60 s (registry/server.mjs
@@ -158,7 +159,7 @@ export async function runDash(hub, { probe, token = githubToken, now = Date.now(
     // The note rides on a post that's going out anyway: a skip alone doesn't
     // wake main (a lasting outage shows as the Dash going stale).
     const body = lines.length ? (lines.length === 1 ? lines[0] : `${lines.length} changes\n${lines.map((l) => `- ${l}`).join("\n")}`) : null;
-    const text = body ? `@main dash: ${body}${note ? `\n(${note})` : ""}` : null;
+    const text = body ? `@${coordinatorOf(snap?.agents)} dash: ${body}${note ? `\n(${note})` : ""}` : null;
     return { posts: text ? [text] : [], state: changed ? { ...state, ...(saved?.pass ? { pass: saved.pass } : {}) } : saved, changed };
   }, { now });
   if (ok) await hub.dashChecked(prFacts);

package/schedules/hub.mjs

@@ -1,14 +1,15 @@
-// main's schedules talk to the registry over its HTTP API
+// The coordinator's schedules talk to the registry over its HTTP API
 // (ROSTER_REGISTRY_URL): a handler's own output (`to()`) never reaches the
 // hub, so they read /api/state and post into their schedule's thread
-// (sch-main-<id>) as "system", which wakes whoever the text @-mentions.
+// (sch-<coordinator>-<id>) as "system", which wakes whoever the text @-mentions.
 //
 // Plain JS on purpose: the schedules (TypeScript, bundled by eve) and the
 // tests (plain node) import the same module.
 import { createHash } from "node:crypto";
 import { registryBase, registryFetch } from "../registry-fetch.mjs";
+import { coordinatorOf } from "../workspace.mjs";
 
-export function createHub({ base = registryBase(), agent = "main", fetchImpl = fetch, log = console } = {}) {
+export function createHub({ base = registryBase(), agent, fetchImpl = fetch, log = console } = {}) {
   const call = async (path, init = {}) => {
     const res = await registryFetch(path, { ...init, headers: { "content-type": "application/json", ...(init.headers ?? {}) } }, { base, fetchImpl, deadlineMs: 10_000 });
     const text = await res.text();
@@ -25,32 +26,36 @@ export function createHub({ base = registryBase(), agent = "main", fetchImpl = f
   };
   // The run the hub is following for this process's handler (`track`), so a commit says which run it belongs to.
   let run = null;
-  const threadOf = (id) => `sch-${agent}-${id.replaceAll("/", ".")}`;
-  const statePath = (id) => `/api/schedules/${encodeURIComponent(agent)}/${id.split("/").map(encodeURIComponent).join("/")}/state`;
+  // The schedules run as the coordinator; with no `agent` given, its name is read once from the hub's roster.
+  let named = agent ? Promise.resolve(agent) : null;
+  const who = () => (named ??= must("/api/state").then((s) => coordinatorOf(s?.agents)));
+  const threadOf = async (id) => `sch-${await who()}-${id.replaceAll("/", ".")}`;
+  const statePath = async (id) => `/api/schedules/${encodeURIComponent(await who())}/${id.split("/").map(encodeURIComponent).join("/")}/state`;
   return {
     snapshot: () => must("/api/state"),
     roster: () => must("/api/roster"),
-    load: async (id) => (await must(statePath(id)))?.state ?? null,
+    load: async (id) => (await must(await statePath(id)))?.state ?? null,
     // The state and when it was saved (the version a run decided on).
     loadVersioned: async (id) => {
-      const body = await must(statePath(id));
+      const body = await must(await statePath(id));
       return { state: body?.state ?? null, savedAt: body?.savedAt ?? null, paused: body?.paused === true };
     },
-    save: (id, state) => must(statePath(id), { method: "PUT", body: JSON.stringify({ state }) }),
+    save: async (id, state) => must(await statePath(id), { method: "PUT", body: JSON.stringify({ state }) }),
     // Save `state` (if given: { state }) and post `posts` in one step.
-    commit: (id, withState, posts) => must(statePath(id), { method: "PUT", body: JSON.stringify({ ...withState, posts, ...(run?.id === id ? { run: run.run } : {}) }) }),
+    commit: async (id, withState, posts) => must(await statePath(id), { method: "PUT", body: JSON.stringify({ ...withState, posts, ...(run?.id === id ? { run: run.run } : {}) }) }),
     // One dispatch of the schedule `id`: the hub is told it started (it answers with the run's id and whether the
     // schedule is paused, which skips `fn`) and how it ended, so the hub's run history is what the handler did. A hub
     // that doesn't keep run history (the local one) answers 404 to the start, and `fn` runs untracked.
     track: async (id, fn) => {
-      const started = await call(`${statePath(id).slice(0, -"/state".length)}/runs`, { method: "POST", body: "{}" }).catch(() => null);
+      const runs = `${(await statePath(id)).slice(0, -"/state".length)}/runs`;
+      const started = await call(runs, { method: "POST", body: "{}" }).catch(() => null);
       if (!started?.ok) return fn();
       if (started.body.paused) {
-        log.log(`schedule ${agent}/${id} skipped: paused`);
+        log.log(`schedule ${await who()}/${id} skipped: paused`);
         return;
       }
       run = { id, run: started.body.run };
-      const end = (error) => call(`${statePath(id).slice(0, -"/state".length)}/runs/${encodeURIComponent(run.run)}/end`, { method: "POST", body: JSON.stringify(error ? { error: error.slice(0, 2000) } : {}) }).catch(() => null);
+      const end = (error) => call(`${runs}/${encodeURIComponent(run.run)}/end`, { method: "POST", body: JSON.stringify(error ? { error: error.slice(0, 2000) } : {}) }).catch(() => null);
       try {
         const result = await fn();
         await end();
@@ -63,23 +68,23 @@ export function createHub({ base = registryBase(), agent = "main", fetchImpl = f
       }
     },
     // A one-off post outside a run (runOnce commits through `commit`).
-    post: (id, text, key) => must(`/api/threads/${encodeURIComponent(threadOf(id))}/messages`, { method: "POST", body: JSON.stringify({ author: "system", text, ...(key ? { clientId: key } : {}) }) }),
+    post: async (id, text, key) => must(`/api/threads/${encodeURIComponent(await threadOf(id))}/messages`, { method: "POST", body: JSON.stringify({ author: "system", text, ...(key ? { clientId: key } : {}) }) }),
     // The Dash was scanned now (hosted-hub/src/domain/dash.mjs checkedAt), changed or not.
     // `prFacts` ({ "owner/repo#12": { head, ci } }): what the scan's GitHub query said of the PRs reviews are about.
-    dashChecked: (prFacts = {}) => must("/api/dash/checked", { method: "POST", body: JSON.stringify({ by: agent, prFacts }) }),
+    dashChecked: async (prFacts = {}) => must("/api/dash/checked", { method: "POST", body: JSON.stringify({ by: await who(), prFacts }) }),
     // A track's summary (set_summary's endpoint, as main).
-    setSummary: (path, text) => must("/api/summaries", { method: "POST", body: JSON.stringify({ by: agent, scope: `path:${path}`, text }) }),
+    setSummary: async (path, text) => must("/api/summaries", { method: "POST", body: JSON.stringify({ by: await who(), scope: `path:${path}`, text }) }),
     // A classifier pass finished (hosted-hub/src/domain/dash.mjs classifiedAt).
-    dashClassified: () => must("/api/dash/classified", { method: "POST", body: JSON.stringify({ by: agent }) }),
+    dashClassified: async () => must("/api/dash/classified", { method: "POST", body: JSON.stringify({ by: await who() }) }),
     // Dash entries from the classifier (hosted-hub/src/domain/dash.mjs), merged per field.
     // File an unfiled thread into a track (the classifier's pick), as a bot:
     // the hub refuses a thread that's already filed and doesn't lock it.
-    fileThread: (threadId, path) => must(`/api/threads/${encodeURIComponent(threadId)}/track`, { method: "POST", body: JSON.stringify({ by: agent, path }) }),
+    fileThread: async (threadId, path) => must(`/api/threads/${encodeURIComponent(threadId)}/track`, { method: "POST", body: JSON.stringify({ by: await who(), path }) }),
     // The plan main's pass made (wire DashPlanIn, checked in hosted-hub/src/domain/dash.mjs normalizePlan); the hub keeps it as the newest.
-    dashPlan: (basis, plan) => must("/api/dash/plan", { method: "POST", body: JSON.stringify({ by: agent, basis, plan }) }),
+    dashPlan: async (basis, plan) => must("/api/dash/plan", { method: "POST", body: JSON.stringify({ by: await who(), basis, plan }) }),
     // `notice` ({ schedule, text, clientId? }): posted in that schedule's
     // thread in the same write as the entries, or neither is kept.
-    dashEntries: (entries, remove = [], notice = null) => must("/api/dash/entries", { method: "POST", body: JSON.stringify({ by: agent, entries, remove, ...(notice ? { notice } : {}) }) }),
+    dashEntries: async (entries, remove = [], notice = null) => must("/api/dash/entries", { method: "POST", body: JSON.stringify({ by: await who(), entries, remove, ...(notice ? { notice } : {}) }) }),
   };
 }
 

package/self-restart.mjs

@@ -16,26 +16,27 @@
 
 export const SELF_STOP_COMMANDS = ["stop", "restart"];
 
-// main restarts the hub with its restart_hub tool (the registry hands it to
-// a detached `hub restart` and re-delivers main's turn afterwards); every
-// other bot asks main.
-export function selfStopMessage(command = "restart", agent) {
+// The coordinator (`coordinator`: its name) restarts the hub with its restart_hub tool (the
+// registry hands it to a detached `hub restart` and re-delivers its turn afterwards); every
+// other bot asks it.
+export function selfStopMessage(command = "restart", agent, coordinator) {
   const who = agent ? ` (${agent})` : "";
   const why =
     command === "stop"
       ? `stops the whole hub, and this bot's own server${who} with it`
       : `replaces the registry this bot reports through, and respawns this bot's own server${who} if its code, env or config changed`;
   const head = `refused: \`hub ${command}\` ${why}, so it could kill the turn running it and that turn would never report back. Nothing was run.\n`;
-  if (agent === "main") {
+  if (coordinator && agent === coordinator) {
     return (
       head +
       `  - The whole hub: call the \`restart_hub\` tool. It runs the restart outside your server and re-delivers this turn if the restart cuts it off.\n` +
       `  - One bot (its config, role or code changed): \`restart_agent <name>\`.`
     );
   }
+  if (!coordinator) return head + `  - Ask the human in the thread to run \`hub ${command}\` from a terminal.`;
   return (
     head +
-    `  - Ask main in the thread: main restarts the whole hub (\`restart_hub\`), or just one bot (\`restart_agent <name>\`, which waits until that bot is idle and re-delivers any turn it cuts off).`
+    `  - Ask ${coordinator} in the thread: ${coordinator} restarts the whole hub (\`restart_hub\`), or just one bot (\`restart_agent <name>\`, which waits until that bot is idle and re-delivers any turn it cuts off).`
   );
 }
 

package/sync-kit.d.mts

@@ -5,7 +5,7 @@ export type KitChange = {
   report: { bot: string; file: string; reason: string }[];
   instructions: Record<string, string>;
 };
-export function syncKit(input: { bots: KitBot[]; modules: Iterable<string> }): KitChange;
+export function syncKit(input: { bots: KitBot[]; modules: Iterable<string>; coordinator: string }): KitChange;
 export function isKitFile(file: string): boolean;
 export function readBotFiles(agentDir: string): Record<string, string>;
 export function applyKit(change: Pick<KitChange, 'write' | 'delete'>, dirOf: (bot: string) => string): void;

package/sync-kit.mjs

@@ -52,13 +52,14 @@ function kitImports(text) {
  * that ships the result should refuse it), instructions { [bot]: source }.
  * Only a plain kit re-export is deleted or replaced.
  */
-export function syncKit({ bots, modules }) {
+export function syncKit({ bots, modules, coordinator }) {
+  if (coordinator !== null && (typeof coordinator !== "string" || !coordinator)) throw new Error(`syncKit needs the coordinator's name, or null for a team with none (coordinatorOf in workspace.mjs), not ${JSON.stringify(coordinator)}`);
   const kit = new Set(modules);
   const change = { write: [], delete: [], report: [], instructions: {} };
   for (const { name: bot, runsOn, files: found, subagents = [] } of bots) {
     if (runsOn !== "local" && runsOn !== "hosted") throw new Error(`${bot}: runsOn must be "local" or "hosted", not ${JSON.stringify(runsOn)}`);
     const local = runsOn === "local";
-    const main = bot === "main";
+    const main = bot === coordinator;
     const stubs = main ? MAIN_KIT_FILES : KIT_FILES;
     const files = { ...found };
     const has = (file) => typeof files[file] === "string";

package/templates/execution-context-local-main.md

@@ -1,6 +1,6 @@
-- **Team.** `create_agent` adds a bot to the workspace; if nobody on the team covers the work well, create a specialist (name, model, role, instructions), then route to it. Give planners and reviewers `preset: "read-only"` so they can't edit files. `remove_agent` removes a bot from the team and shuts it down (name); use it when the human asks. It can't remove main or humans.
+- **Team.** `create_agent` adds a bot to the workspace; if nobody on the team covers the work well, create a specialist (name, model, role, instructions), then route to it. Give planners and reviewers `preset: "read-only"` so they can't edit files. `remove_agent` removes a bot from the team and shuts it down (name); use it when the human asks. It can't remove you (the coordinator) or humans.
 - **Memory.** A new memory entry ships in the next workspace sync PR; each bot recalls it on its next turn, as a `Standing decision <id>:` or `Your standing decision <id>:` message.
 - **Summaries.** Your `dash` schedule rewrites the summary of every track with a thread that has new messages (one model call per track, from the old summary and those threads), every 8 minutes and as soon as a bot's turn ends; you needn't, but a summary you write with `set_summary` stands until a thread on the track moves again. `list_threads` returns thread and track summaries, and the classifier files threads by them.
 - **Classifier.** Your `dash` schedule classifies every non-deferred thread, busy ones included, whenever its facts change (at most once a minute) and otherwise on a growing backoff, and writes the entries itself. It reads the thread; whether it waits on the human is the model's call. You don't rewrite the Dash on each tick.
-- **Ticks.** The same schedule also scans PRs, threads where a bot asks the human, and Dash threads that moved on, and posts in `sch-main-dash` only when something changed. On a tick, fix only what the classifier got wrong with `dash_update` (fields you leave out keep their value): change a `lane` (with its `reason`) the classifier got wrong, raise `importance` for what matters more given the human's role, set `deferred: true` for work the human parked, `remove` an entry that no longer applies. Often nothing needs changing. Don't reply in the tick thread beyond a one-line note, and mention nobody.
+- **Ticks.** The same schedule also scans PRs, threads where a bot asks the human, and Dash threads that moved on, and posts in your `dash` schedule thread (`sch-<your name>-dash`) only when something changed. On a tick, fix only what the classifier got wrong with `dash_update` (fields you leave out keep their value): change a `lane` (with its `reason`) the classifier got wrong, raise `importance` for what matters more given the human's role, set `deferred: true` for work the human parked, `remove` an entry that no longer applies. Often nothing needs changing. Don't reply in the tick thread beyond a one-line note, and mention nobody.
 - **Unfiled paths.** The classifier files unfiled threads onto an existing path in their project. When none fits, one notice gives every unfiled thread in that project alongside every path in use. Read their briefs and put each on a listed path where one fits, or a new `project/feature` path, with `update_thread` (`threadId` and `path` only, including threads you aren't in). Merge near-duplicates with `move_path`. Never move a human-locked path.

package/templates/execution.md

@@ -9,7 +9,7 @@
 - **Figure it out before you ask**
   - Read the code, run it, check the logs and the thread history first.
   - Most problems are already solved: find the standard tool or prior art before designing anything.
-  - For a specialty you don't have, ask main or the bot whose role fits before you ask the human.
+  - For a specialty you don't have, ask the coordinator or the bot whose role fits before you ask the human.
   - Ask the human only for what only they have: a decision between real options, a preference, access, or a look. Ask once, with what you found and the option you recommend.
   - Act freely on what's reversible and yours (a branch, a draft PR, a probe). Ask before what's irreversible or seen by others (a merge, a deploy, a post outside the workspace).
   - Why: every question costs the human a context switch, and most answers are in the code or the history.

package/templates/main-instructions.md

@@ -1,4 +1,4 @@
-You are **main**, the human's chief of staff. The human talks to you first, and you make sure what they ask for gets done. You scope it, put the right bot on it, and stay on it across turns and threads until it lands. A quick question you can settle from what you already know ("where is X?") you answer directly, without opening a thread. You are relentless. You work long stretches without being prodded. When something blocks a bot (a missing grant, an answer only the human has, a bot going in circles), you clear it yourself, put the right bot on it, or get it from the one person who can. Every turn, you look for the next step that moves something forward. You work between the bots that do the work, never as one of them: you don't build or review, because a chief of staff inside one task stops watching the others.
+You are the **coordinator**, the human's chief of staff. The human talks to you first, and you make sure what they ask for gets done. You scope it, put the right bot on it, and stay on it across turns and threads until it lands. A quick question you can settle from what you already know ("where is X?") you answer directly, without opening a thread. You are relentless. You work long stretches without being prodded. When something blocks a bot (a missing grant, an answer only the human has, a bot going in circles), you clear it yourself, put the right bot on it, or get it from the one person who can. Every turn, you look for the next step that moves something forward. You work between the bots that do the work, never as one of them: you don't build or review, because a chief of staff inside one task stops watching the others.
 
 **Take the ask.** First look for an open thread on the same work (`list_threads`) and continue there. Otherwise, `create_thread` with a `path` and an `issueType` already in use. A path is `project/track`: reuse the area's path, and start a new one only for a new effort, named for the feature. The thread's first message mentions only the bot who starts. It gives the goal, the constraints, what done looks like, and "validate with the human" when the scope needs their yes. Building waits for that yes. Route by fit: unclear scope, many parts or real risk go to a planner, and a clear, small change goes straight to a builder. A thread the human starts reaches you untitled: file it with one `update_thread`, then route it inside that thread. Tell the human in one or two lines what you opened and who's on it.
 

package/tools/create_thread.js

@@ -18,7 +18,7 @@ export default defineTool({
         const res = await registryFetch(`/api/threads`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ title, message, author: "main", sessionId: ctx.session.id, focus, project, issueType, projectLabel, issueTypeLabel, path, pathLabel }),
+            body: JSON.stringify({ title, message, sessionId: ctx.session.id, focus, project, issueType, projectLabel, issueTypeLabel, path, pathLabel }),
         });
         if (!res.ok)
             throw new Error(`create_thread failed: ${res.status} ${await res.text()}`);

package/vercel.mjs

@@ -5,12 +5,17 @@
 // Vercel build: elsewhere this file's cwd is a person's checkout.
 import { withEve } from "eve/vercel";
 import { prepareDeployment } from "./prepare.mjs";
+import { coordinatorOf, readWorkspaceFile } from "./workspace.mjs";
 
-if (process.env.VERCEL) prepareDeployment(process.cwd());
+const dir = process.cwd();
+if (process.env.VERCEL) prepareDeployment(dir);
 
 // Each agents/<name>/agent is its own service at /eve/<name>/v1/*. eve
-// publishes only its own transport routes, so main's /hub/manifest channel
-// route (agents/main/agent/channels/manifest.ts) is routed here.
+// publishes only its own transport routes, so the coordinator's /hub/manifest
+// channel route (agents/<coordinator>/agent/channels/manifest.ts, which
+// prepare.mjs writes) is routed here.
+const coordinator = coordinatorOf(readWorkspaceFile(dir).agents);
+if (!coordinator) throw new Error(`${dir}: hub.workspace.json names no coordinator to serve /hub/manifest`);
 export default await withEve({
-  routes: [{ src: "^/hub/manifest$", destination: { type: "service", service: "eve-main" } }],
+  routes: [{ src: "^/hub/manifest$", destination: { type: "service", service: `eve-${coordinator}` } }],
 });

package/workspace.mjs

@@ -58,6 +58,19 @@ export const KINDS = ["coordinator", "planner", "builder", "reviewer", "git-ops"
 
 export class WorkspaceError extends Error {}
 
+// The coordinator's name: the one bot whose `kind` is "coordinator", or null when the team has
+// none (a workspace of only its own bots is valid). Its name is only a name (new workspaces call
+// it `chief`, older ones `main`), so nothing decides by it.
+export function coordinatorOf(agents) {
+  const list = agents ?? [];
+  const found = list.filter((a) => a.kind === "coordinator");
+  if (found.length > 1) throw new WorkspaceError(`${WORKSPACE_FILE}: expected at most one agent with "kind": "coordinator", found ${found.length} (${found.map((a) => a.name).join(", ")})`);
+  if (found.length) return found[0].name;
+  // Manifests scaffolded before kinds existed (#622) set no `kind` on `main`; it stays the coordinator
+  // after kind-tagged teammates join. A `main` given another kind is not one.
+  return list.some((a) => a.name === "main" && !("kind" in a)) ? "main" : null;
+}
+
 const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const fail = (file, message) => {
   throw new WorkspaceError(`${file}: ${message}`);