hub-runner 0.2.1 → 0.2.2

package/check.mjs

@@ -0,0 +1,1336 @@
+import { createRequire as __hubCreateRequire } from 'node:module'; const require = __hubCreateRequire(import.meta.url);
+
+// ../../hosted-hub/runner/check.ts
+import { mkdtempSync, readFileSync as readFileSync3, rmSync as rmSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join3, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+// ../../lib/clean-env.mjs
+var INHERITED_ENV = /^(EVE_|WORKFLOW_)/;
+function cleanEnv(env = process.env) {
+  return Object.fromEntries(Object.entries(env).filter(([key]) => !INHERITED_ENV.test(key)));
+}
+
+// ../../lib/processes.mjs
+import { spawn, execFile, execFileSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, readdirSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { join } from "node:path";
+
+// ../../lib/fingerprint.mjs
+var TREE_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".DS_Store"]);
+function fingerprintDiff(recorded, current) {
+  if (!recorded?.hash) return "it was started without a fingerprint (by an older registry)";
+  if (recorded.hash === current.hash) return null;
+  const parts = Object.keys({ ...recorded.parts, ...current.parts }).filter((k) => recorded.parts?.[k] !== current.parts[k]);
+  const out = [];
+  for (const part of parts) {
+    if (part !== "env" || !recorded.envKeys) {
+      out.push(part);
+      continue;
+    }
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(recorded.envKeys), ...Object.keys(current.envKeys)])].filter((k) => recorded.envKeys[k] !== current.envKeys[k]).sort();
+    out.push(`env (${keys.slice(0, 8).join(", ")}${keys.length > 8 ? `, +${keys.length - 8} more` : ""})`);
+  }
+  return `it was started with different ${out.join(", ") || "inputs"}`;
+}
+var BUILD_SKIP = /* @__PURE__ */ new Set([...TREE_SKIP, ".eve", ".output"]);
+
+// ../../lib/processes.mjs
+var num = (key, fallback) => {
+  const raw = process.env[key];
+  return raw === void 0 || raw === "" || !Number.isFinite(Number(raw)) ? fallback : Number(raw);
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var CRASH_LIMIT = num("ROSTER_CRASH_LIMIT", 5);
+var CRASH_WINDOW_MS = num("ROSTER_CRASH_WINDOW_MS", 10 * 6e4);
+var BACKOFF_BASE_MS = num("ROSTER_BACKOFF_BASE_MS", 1e3);
+var BACKOFF_MAX_MS = num("ROSTER_BACKOFF_MAX_MS", 6e4);
+var HEALTH_TIMEOUT_MS = num("ROSTER_START_HEALTH_TIMEOUT_MS", 12e4);
+var PORT_RECHECK_MS = num("ROSTER_PORT_RECHECK_MS", 5e3);
+var KILL_GRACE_MS = 3e3;
+var WATCH_MS = 1e3;
+var TREE_MS = 5e3;
+var LOG_ROTATE_BYTES = 2e7;
+function groupAlive(pgid) {
+  if (!(pgid > 1)) return false;
+  try {
+    process.kill(-pgid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function pidAlive(pid) {
+  if (!(pid > 1)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var C = { ...process.env, LC_ALL: "C" };
+var SLOW_MS = 1e3;
+function slow(what, started) {
+  const ms = Date.now() - started;
+  if (ms >= SLOW_MS) console.warn(`[registry] ${what} took ${ms}ms`);
+}
+var LSTART = String.raw`(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})`;
+function table() {
+  try {
+    const started = Date.now();
+    const out = execFileSync("ps", ["-A", "-o", "pid=", "-o", "ppid=", "-o", "pgid=", "-o", "rss=", "-o", "lstart=", "-o", "command="], { encoding: "utf8", env: C, stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
+    slow("ps -A", started);
+    const re = new RegExp(String.raw`^(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+${LSTART}\s+(.*)$`);
+    return out.split("\n").map((line) => line.trim().match(re)).filter(Boolean).map((m) => ({ pid: Number(m[1]), ppid: Number(m[2]), pgid: Number(m[3]), rssKb: Number(m[4]), startedAt: Date.parse(m[5]), command: m[6] }));
+  } catch {
+    return [];
+  }
+}
+function treeOf(pid, rows) {
+  const byPid = new Map(rows.map((r) => [r.pid, r]));
+  const children = /* @__PURE__ */ new Map();
+  for (const r of rows) (children.get(r.ppid) ?? children.set(r.ppid, []).get(r.ppid)).push(r);
+  const out = [];
+  const queue = byPid.has(pid) ? [byPid.get(pid)] : [];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length) {
+    const r = queue.shift();
+    if (seen.has(r.pid)) continue;
+    seen.add(r.pid);
+    out.push({ pid: r.pid, pgid: r.pgid, startedAt: r.startedAt });
+    queue.push(...children.get(r.pid) ?? []);
+  }
+  return out;
+}
+function liveMembers(tree, rows) {
+  const byPid = new Map(rows.map((r) => [r.pid, r]));
+  return (tree ?? []).filter((m) => byPid.get(m.pid)?.startedAt === m.startedAt);
+}
+function listeners(port) {
+  const started = Date.now();
+  return new Promise((resolve2, reject) => {
+    execFile("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { encoding: "utf8" }, (error, stdout) => {
+      slow(`lsof :${port}`, started);
+      if (error && error.code !== 1) return reject(error);
+      resolve2(error ? [] : stdout.split(/\s+/).filter(Boolean).map(Number));
+    });
+  });
+}
+function describe(pid, rows) {
+  const row = rows.find((r) => r.pid === pid);
+  return row ? `pid ${pid}: ${row.command.slice(0, 120)}` : `pid ${pid}`;
+}
+function signalGroup(pgid, signal) {
+  if (!(pgid > 1)) return;
+  try {
+    process.kill(-pgid, signal);
+  } catch {
+  }
+}
+async function healthy(port, ms = 1e3) {
+  try {
+    return (await fetch(`http://127.0.0.1:${port}/eve/v1/health`, { signal: AbortSignal.timeout(ms) })).ok;
+  } catch {
+    return false;
+  }
+}
+var merge = (...lists) => [...new Map(lists.flat().map((m) => [m.pid, m])).values()];
+function createSupervisor({
+  root,
+  // the workspace: eve dev's cwd
+  stateDir,
+  env,
+  // spawn environment (already cleaned), or a function of the agent returning it per spawn
+  command,
+  // [file, ...leadingArgs]
+  stopTimeoutMs = 15e3,
+  isCurrent = () => true,
+  // is this agent object still on the roster?
+  // ({ agent, env, argv }) -> what a server spawned now runs with
+  // (lib/fingerprint.mjs), or null. A previous registry's server is
+  // adopted only if its recorded fingerprint matches.
+  fingerprint = null,
+  onChange = () => {
+  },
+  // status changed (broadcast)
+  onUsage = () => {
+  },
+  // a running tree's memory changed (status() reports rssKb)
+  onRecovered = () => {
+  },
+  // healthy again after a crash restart
+  onUp = () => {
+  },
+  // a server is serving: adopted, spawned, or respawned ({ startedAt, adopted, recovered })
+  log = (line) => console.log(line),
+  warn = (line) => console.warn(line)
+}) {
+  const recordsPath = join(stateDir, "processes.json");
+  const logDir = join(stateDir, "logs");
+  const entries = /* @__PURE__ */ new Map();
+  let closed = false;
+  let starting = Promise.resolve();
+  const signature = (name, port) => ` dev --agent ${name} --port ${port} `;
+  const argvFor = (name, port) => [...command, "dev", "--agent", name, "--port", String(port), "--no-ui", "--no-default-extensions", "--resume"];
+  const envFor = (agent) => typeof env === "function" ? env(agent) : env;
+  const fingerprintFor = (agent, spawnEnv = envFor(agent)) => fingerprint ? fingerprint({ agent, env: spawnEnv, argv: argvFor(agent.name, agent.port) }) : null;
+  function persist() {
+    const records = [...entries.values()].filter((e) => e.pid || e.status === "crashed").map((e) => ({
+      agent: e.name,
+      pid: e.pid,
+      pgid: e.pgid,
+      port: e.port,
+      workspace: root,
+      startedAt: e.startedAt,
+      restarts: e.restarts,
+      status: e.status,
+      ...e.tree?.length ? { tree: e.tree } : {},
+      ...e.lastExit ? { lastExit: e.lastExit } : {},
+      ...e.fingerprint ? { fingerprint: e.fingerprint } : {},
+      // The daemon token it was spawned with (HUB_INSTANCE): an adopted bot
+      // keeps its spawner's, and lib/daemon.mjs selfStopRefusal checks it here.
+      ...e.instance ? { instance: e.instance } : {}
+    }));
+    mkdirSync(stateDir, { recursive: true });
+    const tmp = `${recordsPath}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(records, null, 2)}
+`);
+    renameSync(tmp, recordsPath);
+  }
+  function readRecords() {
+    for (const f of existsSync(stateDir) ? readdirSync(stateDir) : []) if (/^processes\.json\.\d+\.tmp$/.test(f)) rmSync(join(stateDir, f), { force: true });
+    try {
+      const records = JSON.parse(readFileSync(recordsPath, "utf8"));
+      return Array.isArray(records) ? records : [];
+    } catch {
+      return [];
+    }
+  }
+  function changed(entry) {
+    persist();
+    onChange(entry.name);
+  }
+  const tails = /* @__PURE__ */ new Map();
+  function follow(name, file, offset) {
+    tails.set(name, { file, offset, carry: "", prefix: `[${name}]`.padEnd(20) });
+  }
+  function pump() {
+    for (const tail of tails.values()) {
+      let size;
+      try {
+        size = statSync(tail.file).size;
+      } catch {
+        continue;
+      }
+      if (size < tail.offset) tail.offset = 0;
+      if (size === tail.offset) continue;
+      const length = Math.min(size - tail.offset, 1e6);
+      const buffer = Buffer.alloc(length);
+      const fd = openSync(tail.file, "r");
+      try {
+        readSync(fd, buffer, 0, length, tail.offset);
+      } finally {
+        closeSync(fd);
+      }
+      tail.offset += length;
+      const lines = (tail.carry + buffer.toString("utf8")).split("\n");
+      tail.carry = lines.pop();
+      for (const line of lines) if (line.trim() && !line.startsWith("Migration file of version")) log(`${tail.prefix} ${line}`);
+    }
+  }
+  const pumpTimer = setInterval(pump, 250);
+  pumpTimer.unref();
+  function refreshTree(entry, rows = table()) {
+    if (!entry.pid) return;
+    const before = JSON.stringify(entry.tree ?? []);
+    entry.tree = merge(treeOf(entry.pid, rows), liveMembers(entry.tree, rows));
+    const own = rows.filter((r) => r.pid === entry.pid || r.ppid === entry.pid);
+    const rss = entry.rssKb;
+    if (own.length) entry.rssKb = own.reduce((sum, r) => sum + (r.rssKb || 0), 0);
+    if (JSON.stringify(entry.tree) !== before) persist();
+    if (entry.rssKb !== rss) onUsage(entry.name);
+  }
+  const treeTimer = setInterval(() => {
+    const live = [...entries.values()].filter((e) => e.pid && !e.stopping);
+    if (!live.length) return;
+    const rows = table();
+    for (const e of live) refreshTree(e, rows);
+  }, TREE_MS);
+  treeTimer.unref();
+  const treeAlive = (pgid, tree) => groupAlive(pgid) || liveMembers(tree, table()).length > 0;
+  async function untilTreeGone(pgid, tree, ms) {
+    const deadline = Date.now() + ms;
+    while (treeAlive(pgid, tree)) {
+      if (Date.now() >= deadline) return false;
+      await sleep(200);
+    }
+    return true;
+  }
+  function killTree(pgid, tree) {
+    signalGroup(pgid, "SIGKILL");
+    for (const g of new Set(liveMembers(tree, table()).map((m) => m.pgid))) signalGroup(g, "SIGKILL");
+  }
+  async function stopTree(pgid, tree, name) {
+    if (!treeAlive(pgid, tree)) return true;
+    let membersTermed = false;
+    const termMembers = () => {
+      membersTermed = true;
+      for (const g of new Set(liveMembers(tree, table()).map((m) => m.pgid))) if (g !== pgid) signalGroup(g, "SIGTERM");
+    };
+    if (groupAlive(pgid)) signalGroup(pgid, "SIGTERM");
+    else termMembers();
+    const deadline = Date.now() + stopTimeoutMs;
+    let gone = true;
+    while (treeAlive(pgid, tree)) {
+      if (!membersTermed && !groupAlive(pgid)) termMembers();
+      if (Date.now() >= deadline) {
+        gone = false;
+        break;
+      }
+      await sleep(200);
+    }
+    if (gone) return true;
+    warn(`[registry] ${name} didn't stop within ${stopTimeoutMs / 1e3}s of SIGTERM; sending SIGKILL`);
+    killTree(pgid, tree);
+    return untilTreeGone(pgid, tree, KILL_GRACE_MS);
+  }
+  const logFile = (name) => join(logDir, `${name}.log`);
+  const sizeOf = (file) => existsSync(file) ? statSync(file).size : 0;
+  function entryFor(agent) {
+    let entry = entries.get(agent.name);
+    if (!entry) {
+      entry = { name: agent.name, agent, port: agent.port, pid: null, pgid: null, startedAt: null, restarts: 0, status: "down", crashes: [], gen: 0, tree: [] };
+      entries.set(agent.name, entry);
+    }
+    entry.agent = agent;
+    entry.port = agent.port;
+    return entry;
+  }
+  function ownsLeader(record, rows) {
+    if (!(record.pid > 1) || record.pgid !== record.pid) return false;
+    const row = rows.find((r) => r.pid === record.pid);
+    if (!row || row.pgid !== record.pgid) return false;
+    if (!` ${row.command} `.includes(signature(record.agent, record.port))) return false;
+    const member = record.tree?.find((m) => m.pid === record.pid);
+    if (member) return member.startedAt === row.startedAt;
+    const recorded = Date.parse(record.startedAt);
+    return !(Number.isFinite(row.startedAt) && Number.isFinite(recorded) && Math.abs(row.startedAt - recorded) > 5e3);
+  }
+  function ourTree(record, rows) {
+    const leader = ownsLeader(record, rows);
+    return { leader, tree: merge(leader ? treeOf(record.pid, rows) : [], liveMembers(record.tree, rows)) };
+  }
+  async function killStale(record, why) {
+    const rows = table();
+    const { leader, tree } = ourTree(record, rows);
+    if (!leader && !tree.length) {
+      if (groupAlive(record.pgid)) warn(`[registry] ! ${record.agent}: process group ${record.pgid} from processes.json is no longer its server; leaving it alone`);
+      return true;
+    }
+    warn(`[registry] ${record.agent}: stopping its stale server (pid ${record.pid}): ${why}`);
+    return stopTree(leader ? record.pgid : null, tree, record.agent);
+  }
+  async function vetAdoption(agent, record) {
+    const rows = table();
+    const { leader, tree } = ourTree(record, rows);
+    if (!leader && !tree.length) return { adopted: false };
+    if (!leader) return { adopted: false, stale: true, why: "its leader is gone" };
+    if (record.port !== agent.port) return { adopted: false, stale: true, why: `its port moved from ${record.port} to ${agent.port}` };
+    if (record.workspace && record.workspace !== root) return { adopted: false, stale: true, why: `it runs workspace ${record.workspace}, not ${root}` };
+    if (fingerprint) {
+      const why = fingerprintDiff(record.fingerprint, fingerprintFor(agent));
+      if (why) return { adopted: false, stale: true, why };
+    }
+    let holders;
+    try {
+      holders = await listeners(agent.port);
+    } catch {
+      return { adopted: false, stale: true, why: "lsof is unavailable, so the port's listener can't be checked" };
+    }
+    if (!holders.some((pid) => tree.some((m) => m.pid === pid))) return { adopted: false, stale: true, why: `nothing of it listens on port ${agent.port}` };
+    return { candidate: true, tree };
+  }
+  async function tryAdopt(agent, record, vetted) {
+    if (!vetted.candidate) return vetted;
+    const before = entries.get(agent.name);
+    const mark = before ? { gen: before.gen, claim: before.claim ?? 0 } : null;
+    const ok = await healthy(agent.port, 2e3);
+    if (!isCurrent(agent)) return { adopted: false, stale: true, why: "its bot left the roster meanwhile" };
+    const now = entries.get(agent.name);
+    if (now && (now.pid || (mark ? now.gen !== mark.gen || (now.claim ?? 0) !== mark.claim : (now.claim ?? 0) > 0))) {
+      return { adopted: false, stale: true, superseded: true, why: "another start of it began meanwhile" };
+    }
+    if (!ok) return { adopted: false, stale: true, why: "/eve/v1/health doesn't answer" };
+    const { tree } = vetted;
+    if (closed) return carry(agent, record, tree);
+    const entry = entryFor(agent);
+    Object.assign(entry, { pid: record.pid, pgid: record.pgid, startedAt: record.startedAt, restarts: record.restarts ?? 0, status: "up", adopted: true, child: null, stopping: false, error: void 0, tree, fingerprint: record.fingerprint, instance: record.instance, rssKb: void 0 });
+    const gen = ++entry.gen;
+    follow(agent.name, logFile(agent.name), sizeOf(logFile(agent.name)));
+    entry.watch = setInterval(() => {
+      if (entry.gen !== gen) return clearInterval(entry.watch);
+      if (!pidAlive(entry.pid)) {
+        clearInterval(entry.watch);
+        exited(entry, gen, { code: null, signal: null });
+      }
+    }, WATCH_MS);
+    entry.watch.unref();
+    log(`[registry] adopted ${agent.name} (pid ${record.pid}, port ${agent.port})`);
+    changed(entry);
+    onUp(agent, { startedAt: entry.startedAt, adopted: true, recovered: false });
+    return { adopted: true };
+  }
+  function carry(agent, record, tree = record.tree ?? []) {
+    const entry = entryFor(agent);
+    Object.assign(entry, { pid: record.pid, pgid: record.pgid, startedAt: record.startedAt, restarts: record.restarts ?? 0, status: record.status ?? "up", adopted: true, child: null, stopping: false, tree, fingerprint: record.fingerprint, instance: record.instance });
+    entry.gen++;
+    return { adopted: true, carried: true };
+  }
+  async function spawnAgent(entry, { recovered = false } = {}) {
+    clearTimeout(entry.timer);
+    entry.timer = void 0;
+    const { agent, name, port } = entry;
+    if (closed || !isCurrent(agent)) return;
+    const claim = entry.claim = (entry.claim ?? 0) + 1;
+    let holders = [];
+    try {
+      holders = await listeners(port);
+    } catch {
+    }
+    if (entry.claim !== claim || closed || !isCurrent(agent)) return;
+    if (holders.length) {
+      const rows = table();
+      const ours = liveMembers(entry.tree, rows);
+      if (holders.every((pid) => ours.some((m) => m.pid === pid))) {
+        killTree(null, ours);
+        await untilTreeGone(null, ours, KILL_GRACE_MS);
+        if (!isCurrent(agent) || entry.stopping) return;
+        return spawnAgent(entry, { recovered });
+      }
+      const error = `port ${port} is held by another process (${holders.map((pid) => describe(pid, rows)).join("; ")}), not by ${name}'s server; not touching it. ${name} starts once the port is free.`;
+      if (entry.error !== error || entry.status !== "blocked") warn(`[registry] ! ${error}`);
+      Object.assign(entry, { status: "blocked", error, pid: null, pgid: null });
+      entry.timer = setTimeout(() => spawnAgent(entry, { recovered }), PORT_RECHECK_MS);
+      entry.timer.unref();
+      return changed(entry);
+    }
+    mkdirSync(logDir, { recursive: true });
+    const file = logFile(name);
+    if (sizeOf(file) > LOG_ROTATE_BYTES) renameSync(file, `${file}.1`);
+    const fd = openSync(file, "a");
+    writeSync(fd, `
+--- ${(/* @__PURE__ */ new Date()).toISOString()} hub: starting ${name} on port ${port}
+`);
+    const [bin, ...args] = argvFor(name, port);
+    const spawnEnv = envFor(agent);
+    let fp = null;
+    try {
+      fp = fingerprintFor(agent, spawnEnv);
+    } catch (error) {
+      warn(`[registry] ! ${name}: couldn't fingerprint its inputs (${error.message}); the next registry respawns it instead of adopting it`);
+    }
+    let child;
+    try {
+      child = spawn(bin, args, {
+        cwd: root,
+        env: spawnEnv,
+        detached: true,
+        // own process group; survives the registry
+        stdio: ["ignore", fd, fd]
+      });
+    } finally {
+      closeSync(fd);
+    }
+    const gen = ++entry.gen;
+    Object.assign(entry, { child, pid: child.pid ?? null, pgid: child.pid ?? null, startedAt: (/* @__PURE__ */ new Date()).toISOString(), status: "starting", adopted: false, stopping: false, error: void 0, nextRestartAt: void 0, tree: [], slowWarned: false, fingerprint: fp ?? void 0, instance: spawnEnv?.HUB_INSTANCE || void 0, rssKb: void 0 });
+    follow(name, file, sizeOf(file));
+    child.once("error", (error) => {
+      warn(`[registry] ! couldn't start ${name}: ${error.message}`);
+      exited(entry, gen, { code: null, signal: null, error: error.message });
+    });
+    child.once("exit", (code, signal) => exited(entry, gen, { code, signal }));
+    refreshTree(entry);
+    changed(entry);
+    void waitHealthy(entry, gen, recovered);
+  }
+  async function waitHealthy(entry, gen, recovered) {
+    const started = Date.now();
+    while (entry.gen === gen && entry.status === "starting") {
+      if (await healthy(entry.port)) {
+        let ours = true;
+        try {
+          const holders = await listeners(entry.port);
+          if (entry.gen !== gen || entry.status !== "starting") return;
+          refreshTree(entry);
+          ours = holders.some((pid) => entry.tree.some((m) => m.pid === pid));
+        } catch {
+        }
+        if (entry.gen !== gen || entry.status !== "starting") return;
+        if (ours) {
+          entry.status = "up";
+          changed(entry);
+          onUp(entry.agent, { startedAt: entry.startedAt, adopted: false, recovered });
+          if (recovered) onRecovered(entry.agent);
+          return;
+        }
+      }
+      if (Date.now() - started > HEALTH_TIMEOUT_MS && !entry.slowWarned) {
+        warn(`[registry] ! ${entry.name} isn't healthy ${HEALTH_TIMEOUT_MS / 1e3}s after starting; see ${logFile(entry.name)}`);
+        entry.slowWarned = true;
+      }
+      await sleep(500);
+    }
+  }
+  function exited(entry, gen, { code, signal, error }) {
+    if (entry.gen !== gen) return;
+    entry.gen++;
+    clearInterval(entry.watch);
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    entry.lastExit = { code, signal, at, ...error ? { error } : {} };
+    const { pgid, tree } = entry;
+    Object.assign(entry, { child: null, pid: null, pgid: null });
+    if (entry.stopping) {
+      entry.status = "down";
+      return changed(entry);
+    }
+    killTree(pgid, tree);
+    if (!isCurrent(entry.agent)) {
+      entry.status = "down";
+      return changed(entry);
+    }
+    const now = Date.now();
+    entry.crashes = [...entry.crashes.filter((t) => now - t < CRASH_WINDOW_MS), now];
+    const how = signal ? `signal ${signal}` : code === null ? "unknown status" : `code ${code}`;
+    if (entry.crashes.length >= CRASH_LIMIT) {
+      entry.status = "crashed";
+      entry.error = `exited ${entry.crashes.length} times within ${Math.round(CRASH_WINDOW_MS / 6e4)} min (last: ${how}); not restarting until restart_agent. Log: ${logFile(entry.name)}`;
+      warn(`[registry] ! ${entry.name} crashed: ${entry.error}`);
+      return changed(entry);
+    }
+    const delay2 = Math.min(BACKOFF_BASE_MS * 2 ** (entry.crashes.length - 1), BACKOFF_MAX_MS);
+    entry.status = "down";
+    entry.nextRestartAt = new Date(now + delay2).toISOString();
+    warn(`[registry] ${entry.name} exited unexpectedly (${how}); restarting in ${delay2 / 1e3}s`);
+    entry.timer = setTimeout(async () => {
+      await untilTreeGone(pgid, tree, KILL_GRACE_MS);
+      if (entry.status !== "down" || entry.stopping) return;
+      entry.restarts++;
+      changed(entry);
+      void spawnAgent(entry, { recovered: true });
+    }, delay2);
+    entry.timer.unref();
+    changed(entry);
+  }
+  return {
+    // Startup: adopt what's still running from a previous registry, start the rest.
+    startAll(agents) {
+      starting = (async () => {
+        const records = readRecords();
+        const byName = new Map(records.map((r) => [r.agent, r]));
+        for (const record of records) {
+          if (agents.some((a) => a.name === record.agent)) continue;
+          await killStale(record, "its bot is no longer on the roster");
+        }
+        const vetted = new Map(await Promise.all(agents.filter((a) => byName.has(a.name)).map(async (a) => [a.name, closed ? { adopted: false } : await vetAdoption(a, byName.get(a.name))])));
+        const results = new Map(await Promise.all([...vetted].map(async ([name, v]) => [name, await tryAdopt(agents.find((a) => a.name === name), byName.get(name), v)])));
+        await Promise.all(
+          agents.map(async (agent) => {
+            const record = byName.get(agent.name);
+            if (record) {
+              const result = results.get(agent.name);
+              if (result.adopted) return;
+              if (closed && !result.superseded) {
+                if (ourTree(record, table()).tree.length) carry(agent, record);
+                return;
+              }
+              await killStale(record, result.why ?? "it isn't serving");
+              if (result.superseded) return;
+            }
+            await spawnAgent(entryFor(agent));
+          })
+        );
+        persist();
+      })();
+      return starting;
+    },
+    // An explicit start (create_agent, restart_agent): clears crash history.
+    start(agent) {
+      if (!isCurrent(agent)) return;
+      const entry = entryFor(agent);
+      if (entry.pid && pidAlive(entry.pid) && !entry.stopping) return;
+      entry.crashes = [];
+      void spawnAgent(entry);
+    },
+    // SIGTERM, then SIGKILL after stopTimeoutMs. True once nothing of it is left.
+    async stop(agent) {
+      const entry = entries.get(agent.name);
+      if (!entry) return true;
+      clearTimeout(entry.timer);
+      entry.timer = void 0;
+      entry.nextRestartAt = void 0;
+      entry.claim = (entry.claim ?? 0) + 1;
+      entry.stopping = true;
+      const { pgid } = entry;
+      if (entry.pid) refreshTree(entry);
+      const tree = entry.tree;
+      if (!treeAlive(pgid, tree)) {
+        if (entry.pgid === pgid) {
+          entry.gen++;
+          clearInterval(entry.watch);
+          Object.assign(entry, { status: "down", pid: null, pgid: null, child: null });
+        }
+        changed(entry);
+        return true;
+      }
+      entry.status = "stopping";
+      changed(entry);
+      const gone = await stopTree(pgid, tree, agent.name);
+      if (gone) {
+        if (entry.pgid === pgid) {
+          entry.gen++;
+          clearInterval(entry.watch);
+          Object.assign(entry, { status: "down", pid: null, pgid: null, child: null });
+        }
+        entry.tree = [];
+        changed(entry);
+      }
+      return gone;
+    },
+    async stopAll() {
+      closed = true;
+      await starting.catch(() => {
+      });
+      clearInterval(pumpTimer);
+      clearInterval(treeTimer);
+      await Promise.all([...entries.values()].map((e) => this.stop(e.agent)));
+      pump();
+      persist();
+    },
+    // Exit without stopping any bot (a `hub restart` that keeps them): nothing
+    // new starts, pending (re)starts are cancelled, each tree is re-read and
+    // saved, and no signal is sent. The next registry vets every record
+    // (vetAdoption) and adopts what still matches. Returns the bots left running.
+    async detach() {
+      closed = true;
+      await starting.catch(() => {
+      });
+      clearInterval(pumpTimer);
+      clearInterval(treeTimer);
+      const rows = table();
+      for (const e of entries.values()) {
+        clearTimeout(e.timer);
+        e.timer = void 0;
+        e.claim = (e.claim ?? 0) + 1;
+        clearInterval(e.watch);
+        e.gen++;
+        if (e.pid) refreshTree(e, rows);
+      }
+      pump();
+      persist();
+      return [...entries.values()].filter((e) => e.pid).map((e) => ({ name: e.name, pid: e.pid }));
+    },
+    // Drop a removed bot's record (after its server is confirmed down).
+    forget(name) {
+      const entry = entries.get(name);
+      if (entry) {
+        clearTimeout(entry.timer);
+        clearInterval(entry.watch);
+        entry.gen++;
+        entry.claim = (entry.claim ?? 0) + 1;
+      }
+      entries.delete(name);
+      tails.delete(name);
+      persist();
+    },
+    // Resolves true once the bot is up (spawned by us and healthy); false
+    // once it can't be: it crashed, left the roster, or this supervisor closed.
+    async waitUp(agent, timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const entry = entries.get(agent.name);
+        if (closed || !isCurrent(agent)) return false;
+        if (entry?.agent === agent && entry.status === "up") return true;
+        if (entry?.status === "crashed") return false;
+        await sleep(250);
+      }
+      return false;
+    },
+    // A running bot's memory as of the last tree refresh (eve dev + its
+    // server) and its uptime (an adopted one keeps its start). Kept out of
+    // status(): that's in every state snapshot, and these change constantly.
+    usage(name) {
+      const e = entries.get(name);
+      if (!e?.pid || e.status !== "up") return void 0;
+      return {
+        ...e.rssKb ? { rssMb: Math.round(e.rssKb / 1024) } : {},
+        ...e.startedAt ? { uptimeS: Math.max(0, Math.round((Date.now() - Date.parse(e.startedAt)) / 1e3)) } : {}
+      };
+    },
+    status(name) {
+      const e = entries.get(name);
+      if (!e) return null;
+      return {
+        status: e.status,
+        pid: e.pid,
+        port: e.port,
+        restarts: e.restarts,
+        startedAt: e.startedAt,
+        ...e.rssKb ? { rssKb: e.rssKb } : {},
+        ...e.adopted ? { adopted: true } : {},
+        ...e.lastExit ? { lastExit: e.lastExit } : {},
+        ...e.error ? { error: e.error } : {},
+        ...e.status === "down" && e.nextRestartAt ? { nextRestartAt: e.nextRestartAt } : {},
+        log: logFile(name)
+      };
+    }
+  };
+}
+
+// ../../hosted-hub/src/dispatch/tags.ts
+var TAGS = [
+  "identity",
+  "team",
+  "execution",
+  "engineering",
+  "what_reaches_you",
+  "reaching_others",
+  "writing",
+  "role",
+  "execution_context",
+  "tools_note",
+  "skills",
+  "standing_decisions",
+  "decision",
+  "about_the_human",
+  "relevant_decisions",
+  "team_architecture",
+  "thread_catchup",
+  "summary",
+  "latest_status",
+  "related_threads",
+  "new_posts",
+  "post",
+  "event",
+  "thread_changes",
+  "team_status",
+  "bot",
+  "message_to_you",
+  "omitted"
+];
+var OPENING = new RegExp(`<(/?)(${TAGS.join("|")})\\b`, "g");
+
+// ../../hosted-hub/src/dispatch/bot.ts
+var ATTEMPT_MS = 15e3;
+var RETRYABLE_4XX = /* @__PURE__ */ new Set([408, 425, 429]);
+var definitive = (status) => status !== null && status >= 400 && status < 500 && !RETRYABLE_4XX.has(status);
+var CreateRefused = class extends Error {
+};
+async function createSession(fetchFn, eve, operationId) {
+  const response = await fetchFn(`${eve.url}/v1/session`, { method: "POST", headers: eve.headers, signal: AbortSignal.timeout(ATTEMPT_MS), body: JSON.stringify({ operationId }) });
+  const text = await response.text();
+  const body = (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return {};
+    }
+  })(), { sessionId } = body;
+  if (definitive(response.status)) throw new CreateRefused(`${response.status} ${body.error ?? body.code ?? text.slice(0, 200)}`);
+  if (!response.ok || !sessionId) throw new Error(`create ${operationId}: HTTP ${response.status} ${text.slice(0, 200)}`);
+  return sessionId;
+}
+
+// ../../lib/v26-facts.mjs
+function factsOfV26(event) {
+  if (!event || typeof event.type !== "string") return { facts: [], progress: false };
+  const data = isRecord(event.data) ? event.data : {};
+  const deliveryIds = Array.isArray(event.meta?.deliveryIds) ? event.meta.deliveryIds.filter((id) => typeof id === "string") : [];
+  const progress = PROGRESS_TYPES.has(event.type);
+  const facts = progress ? progressOf(event.type, data) : committedOf(event.type, data, deliveryIds);
+  return { facts, progress };
+}
+var PROGRESS_TYPES = /* @__PURE__ */ new Set(["message.appended", "reasoning.appended", "action.input.appended", "action.partial"]);
+var TASK_RECEIPT = /^(Started|Sent to) task \S+/;
+var runIdOf = (data) => `v26:run:${str(data.turnId) ?? ""}:${String(data.stepIndex ?? "")}`;
+var partIdOf = (data, kind) => `${runIdOf(data)}:${kind}`;
+var compactionIdOf = (data) => `v26:compaction:${str(data.turnId) ?? ""}:${String(data.stepIndex ?? "")}`;
+var clearIdOf = (data) => `v26:clear:${str(data.turnId) ?? ""}:${String(data.sequence ?? "")}`;
+var signInIdOf = (data) => str(data.attemptId) ?? `v26:sign-in:${str(data.name) ?? "connection"}`;
+var deliveryIdOf = (data) => `v26:delivery:${str(data.turnId) ?? ""}:${String(data.sequence ?? "")}`;
+function progressOf(type, data) {
+  switch (type) {
+    case "message.appended":
+      return [fact("content.delta", { partId: partIdOf(data, "text"), kind: "text", delta: str(data.messageDelta) ?? str(data.delta) ?? "" }, data)];
+    case "reasoning.appended":
+      return [fact("content.delta", { partId: partIdOf(data, "reasoning"), kind: "reasoning", delta: str(data.reasoningDelta) ?? str(data.delta) ?? "" }, data)];
+    case "action.input.appended": {
+      const callId = str(data.callId);
+      return callId === void 0 ? [] : [fact("call.input", { callId, name: str(data.toolName), kind: "tool", delta: str(data.inputTextDelta) ?? "" }, data)];
+    }
+    case "action.partial": {
+      const result = isRecord(data.result) ? data.result : {};
+      const callId = str(result.callId);
+      if (callId === void 0) return [];
+      const label = labelOf(data.presentation, callId);
+      return [fact("call.progress", { callId, output: result.output ?? null, ...label === void 0 ? {} : { label } }, data)];
+    }
+    default:
+      return [];
+  }
+}
+function committedOf(type, data, deliveryIds) {
+  switch (type) {
+    case "session.started":
+      return [fact("session.started", sessionStarted(data))];
+    case "turn.started": {
+      const turnId = str(data.turnId);
+      if (turnId === void 0) return [];
+      return [
+        ...deliveryIds.map((deliveryId) => fact("delivery.admitted", { deliveryId })),
+        fact("turn.started", { turnId, cause: deliveryIds.length ? { deliveryId: deliveryIds[0] } : { policy: "v26" }, follows: null }, data)
+      ];
+    }
+    case "message.received": {
+      const turnId = str(data.turnId);
+      if (turnId === void 0) return [];
+      const parts = userParts(data);
+      const ids = deliveryIds.length ? deliveryIds : [deliveryIdOf(data)];
+      return ids.map((deliveryId) => fact("delivery.consumed", { deliveryId, turnId, parts }, data));
+    }
+    case "step.started": {
+      const runId = runIdOf(data), turnId = str(data.turnId);
+      if (turnId === void 0) return [];
+      return [
+        fact("model.requested", { runId, owner: { turnId } }, data),
+        fact("model.started", { runId, modelId: str(data.modelId) ?? "unknown", attempt: 0 }, data)
+      ];
+    }
+    case "step.completed": {
+      const runId = runIdOf(data);
+      const facts = [fact("model.settled", { runId, outcome: "completed", ...typeof data.finishReason === "string" ? { finishReason: data.finishReason } : {} }, data)];
+      if (isRecord(data.usage)) facts.push(fact("usage.recorded", { owner: { runId }, kind: "model", usage: usageOf(data.usage) }, data));
+      return facts;
+    }
+    case "step.failed":
+      return [fact("model.settled", { runId: runIdOf(data), outcome: "failed", error: errorOf(data) }, data)];
+    case "message.completed": {
+      const value = str(data.message);
+      if (value === void 0) return [];
+      return [content(data, "text", data.finishReason === "tool-calls" ? "narration" : "reply", value)];
+    }
+    case "reasoning.completed": {
+      const value = str(data.reasoning);
+      return value === void 0 ? [] : [content(data, "reasoning", "narration", value)];
+    }
+    case "result.completed":
+      return data.result === void 0 ? [] : [content(data, "result", "reply", data.result)];
+    case "actions.requested": {
+      if (!Array.isArray(data.actions)) return [];
+      const runId = runIdOf(data);
+      return data.actions.flatMap((action) => {
+        if (!isRecord(action) || typeof action.callId !== "string") return [];
+        return [fact("call.requested", { callId: action.callId, owner: { runId }, capability: capabilityOf(action, labelOf(data.presentation, action.callId)), ...action.input === void 0 ? {} : { input: action.input } }, data)];
+      });
+    }
+    case "action.result": {
+      const result = isRecord(data.result) ? data.result : {};
+      const callId = str(result.callId);
+      if (callId === void 0) return [];
+      if (typeof result.output === "string" && TASK_RECEIPT.test(result.output)) return [];
+      const error = isRecord(data.error) ? errorOf(data.error) : void 0;
+      const output = result.output === void 0 ? {} : { output: result.output };
+      const label = labelOf(data.presentation, callId);
+      const labelled = label === void 0 ? {} : { label };
+      if (data.status === "rejected") return [fact("call.settled", { callId, outcome: "rejected", ...output, ...error ? { error } : {}, ...labelled }, data)];
+      const outcome = data.status === "failed" ? "failed" : "completed";
+      return [
+        fact("call.started", { callId }, data),
+        fact("call.settled", { callId, outcome, ...output, ...outcome === "failed" && error ? { error } : {}, ...labelled }, data)
+      ];
+    }
+    case "task.started": {
+      const taskId = str(data.taskId), callId = str(data.callId);
+      if (taskId === void 0 || callId === void 0) return [];
+      return [
+        fact("task.started", { taskId, startedBy: { callId }, kind: str(data.kind) ?? "tool", name: str(data.name) ?? "tool" }, data),
+        fact("call.started", { callId, taskId }, data)
+      ];
+    }
+    case "task.settled": {
+      const taskId = str(data.taskId), callId = str(data.callId);
+      if (taskId === void 0 || callId === void 0) return [];
+      const outcome = data.status === "completed" ? "completed" : data.status === "failed" ? "failed" : "cancelled";
+      const reason = isRecord(data.cancel) && typeof data.cancel.reason === "string" ? { reason: data.cancel.reason.replaceAll("_", "-") } : {};
+      const error = isRecord(data.error) && typeof data.error.message === "string" ? { error: { code: "task_failed", message: data.error.message } } : {};
+      return [
+        fact("task.ended", { taskId, outcome, ...reason, ...error }, data),
+        fact("call.settled", { callId, outcome: outcome === "cancelled" ? "interrupted" : outcome, ...data.output === void 0 ? {} : { output: data.output }, ...reason, ...error }, data)
+      ];
+    }
+    case "agent.started": {
+      const sessionId = str(data.sessionId), callId = str(data.callId);
+      if (sessionId === void 0 || callId === void 0) return [];
+      return [fact("child.opened", { sessionId, owner: { callId }, name: str(data.name) ?? "agent", stream: str(data.streamPath) ?? `/eve/v1/session/${sessionId}/stream` }, data)];
+    }
+    case "input.requested": {
+      if (!Array.isArray(data.requests)) return [];
+      const turnId = str(data.turnId), taskId = str(data.taskId);
+      return data.requests.flatMap((request) => {
+        if (!isRecord(request) || typeof request.requestId !== "string") return [];
+        const action = isRecord(request.action) ? request.action : void 0;
+        const callId = str(data.callId) ?? (action ? str(action.callId) : void 0);
+        if (taskId !== void 0) {
+          const origin = action && str(action.callId) !== void 0 ? { origin: { sessionId: taskId, interactionId: request.requestId, call: { callId: action.callId, name: capabilityOf(action).name, ...action.input === void 0 ? {} : { input: action.input } } } } : {};
+          return [fact("interaction.opened", { interactionId: request.requestId, subject: { taskId }, request: interactionRequest(request), ...origin }, data)];
+        }
+        const subject = callId !== void 0 ? { callId } : turnId !== void 0 ? { turnId } : void 0;
+        if (subject === void 0) return [];
+        return [fact("interaction.opened", { interactionId: request.requestId, subject, request: interactionRequest(request) }, data)];
+      });
+    }
+    case "input.resolved": {
+      if (!Array.isArray(data.resolutions)) return [];
+      return data.resolutions.flatMap((resolution) => {
+        if (!isRecord(resolution) || typeof resolution.requestId !== "string") return [];
+        const response = isRecord(resolution.response) ? resolution.response : {};
+        const value = { ...typeof response.optionId === "string" ? { optionId: response.optionId } : {}, ...typeof response.text === "string" ? { text: response.text } : {} };
+        return [fact("interaction.settled", { interactionId: resolution.requestId, outcome: interactionOutcome(resolution.outcome), ...Object.keys(value).length ? { response: value } : {} }, data)];
+      });
+    }
+    case "approval.settled": {
+      const interactionId = str(data.requestId);
+      if (interactionId === void 0) return [];
+      return [fact("interaction.settled", { interactionId, outcome: data.outcome === "approved" ? "accepted" : "withdrawn" }, data)];
+    }
+    case "approval.candidate": {
+      const responseId = str(data.candidateId), interactionId = str(data.requestId);
+      if (responseId === void 0 || interactionId === void 0) return [];
+      if (data.outcome === "pending") return [fact("response.submitted", { responseId, interactionId, deliveryId: `v26:response:${responseId}` }, data)];
+      const outcome = data.outcome === "rejected" ? "refused" : data.outcome === "failed" ? "failed" : data.outcome === "timed-out" ? "expired" : "withdrawn";
+      return [fact("response.settled", { responseId, outcome, ...typeof data.reason === "string" ? { reason: data.reason } : {} }, data)];
+    }
+    case "authorization.required": {
+      const turnId = str(data.turnId), taskId = str(data.taskId);
+      const subject = taskId !== void 0 ? { taskId } : turnId !== void 0 ? { turnId } : void 0;
+      if (subject === void 0) return [];
+      const principalId = str(data.principalId);
+      return [fact("interaction.opened", { interactionId: signInIdOf(data), subject, request: signInRequest(data), ...principalId === void 0 ? {} : { audience: { principalIds: [principalId] } } }, data)];
+    }
+    case "authorization.completed":
+      return [fact("interaction.settled", { interactionId: signInIdOf(data), outcome: signInOutcome(data.outcome), ...typeof data.reason === "string" ? { reason: data.reason } : {} }, data)];
+    case "turn.waiting": {
+      const turnId = str(data.turnId);
+      if (turnId === void 0 || data.on !== "input") return [];
+      return [fact("turn.paused", { turnId, awaiting: [] }, data)];
+    }
+    case "turn.completed":
+      return turnSettled(data, { outcome: "completed" });
+    case "turn.cancelled":
+      return turnSettled(data, { outcome: "cancelled" });
+    case "turn.failed":
+      return turnSettled(data, { outcome: "failed", error: errorOf(data) });
+    case "context.cleared": {
+      const changeId = clearIdOf(data);
+      return [fact("context.started", { changeId, kind: "clear" }, data), fact("context.settled", { changeId, kind: "clear", outcome: "completed", selects: null }, data)];
+    }
+    case "compaction.requested": {
+      const turnId = str(data.turnId);
+      const trigger = typeof data.usageInputTokens === "number" ? { trigger: { inputTokens: data.usageInputTokens } } : {};
+      return [fact("context.started", { changeId: compactionIdOf(data), kind: "compaction", ...turnId === void 0 ? {} : { turnId }, ...trigger }, data)];
+    }
+    case "compaction.completed":
+      return [fact("context.settled", { changeId: compactionIdOf(data), kind: "compaction", outcome: "completed" }, data)];
+    case "compaction.failed":
+      return [fact("context.settled", { changeId: compactionIdOf(data), kind: "compaction", outcome: "failed", error: errorOf(data) }, data)];
+    case "session.completed":
+      return [fact("session.ended", { outcome: "completed" })];
+    case "session.failed":
+      return [fact("session.ended", { outcome: "failed", error: errorOf(data) })];
+    // session.waiting (idle), history.imported (folded into the next delivery by a stateful reader) and unknown types have no fact.
+    default:
+      return [];
+  }
+}
+function fact(type, data, source) {
+  const scope = {};
+  if (source && typeof source.turnId === "string") scope.turnId = source.turnId;
+  if (source && typeof source.taskId === "string") scope.taskId = source.taskId;
+  if (source && typeof source.turnId === "string" && typeof source.stepIndex === "number" && !NO_RUN_SCOPE.has(type)) scope.runId = runIdOf(source);
+  return Object.keys(scope).length ? { type, data, scope } : { type, data };
+}
+var NO_RUN_SCOPE = /* @__PURE__ */ new Set(["context.started", "context.settled", "interaction.opened", "interaction.settled", "response.submitted", "response.settled"]);
+function content(data, kind, phase, value) {
+  return fact("content.completed", { partId: partIdOf(data, kind), runId: runIdOf(data), kind, phase, value }, data);
+}
+function turnSettled(data, settled) {
+  const turnId = str(data.turnId);
+  return turnId === void 0 ? [] : [fact("turn.settled", { turnId, ...settled }, data)];
+}
+function sessionStarted(data) {
+  const invocation = isRecord(data.invocation) ? data.invocation : {};
+  const parentSessionId = str(invocation.parentSessionId), parentCallId = str(invocation.parentCallId);
+  const predecessor = isRecord(data.predecessor) ? str(data.predecessor.sessionId) : void 0;
+  return {
+    ...parentSessionId !== void 0 && parentCallId !== void 0 ? { parent: { sessionId: parentSessionId, callId: parentCallId } } : {},
+    ...predecessor === void 0 ? {} : { predecessor: { sessionId: predecessor } },
+    ...isRecord(data.runtime) && typeof data.runtime.agentId === "string" ? { runtime: data.runtime } : {},
+    ...isRecord(data.trace) ? { trace: data.trace } : {}
+  };
+}
+function userParts(data) {
+  if (Array.isArray(data.parts)) {
+    return data.parts.flatMap((part) => {
+      if (!isRecord(part)) return [];
+      if (part.type === "text" && typeof part.text === "string") return [{ kind: "text", text: part.text }];
+      if (part.type === "file" && typeof part.mediaType === "string") {
+        const url = str(part.url);
+        return [{ kind: "file", mediaType: part.mediaType, ...str(part.filename) === void 0 ? {} : { filename: part.filename }, ...typeof part.size === "number" ? { size: part.size } : {}, ...url === void 0 ? { unavailable: true } : { url } }];
+      }
+      return [];
+    });
+  }
+  return typeof data.message === "string" ? [{ kind: "text", text: data.message }] : [];
+}
+function capabilityOf(action, label) {
+  const labelled = label === void 0 ? {} : { label };
+  switch (action.kind) {
+    case "subagent-call":
+      return { kind: "agent", name: str(action.name) ?? str(action.subagentName) ?? "agent", ...labelled };
+    case "remote-agent-call":
+      return { kind: "agent", name: str(action.name) ?? str(action.remoteAgentName) ?? "agent", remote: true, ...labelled };
+    case "load-skill":
+      return { kind: "skill", name: str(action.name) ?? "skill", ...labelled };
+    default: {
+      const name = str(action.toolName) ?? str(action.name) ?? "tool";
+      return { kind: name.startsWith("eve__task_") ? "control" : "tool", name, ...labelled };
+    }
+  }
+}
+function labelOf(presentation, callId) {
+  const entry = isRecord(presentation) && isRecord(presentation[callId]) ? presentation[callId] : {};
+  return str(entry.label);
+}
+function interactionRequest(request) {
+  const kind = request.kind === "tool-approval" ? "approval" : request.kind === "session-limit" ? "budget" : "question";
+  const options = Array.isArray(request.options) ? request.options.flatMap((option) => isRecord(option) && typeof option.id === "string" && typeof option.label === "string" ? [{ id: option.id, label: option.label, ...str(option.description) === void 0 ? {} : { description: option.description }, ...option.style === "primary" || option.style === "danger" || option.style === "default" ? { style: option.style } : {} }] : []) : void 0;
+  const display = request.display;
+  return {
+    kind,
+    prompt: str(request.prompt) ?? "",
+    ...options === void 0 ? {} : { options },
+    ...typeof request.allowFreeform === "boolean" ? { allowFreeform: request.allowFreeform } : {},
+    ...display === "confirmation" || display === "select" || display === "text" ? { display } : {}
+  };
+}
+function interactionOutcome(outcome) {
+  switch (outcome) {
+    case "answered":
+    case "approved":
+      return "accepted";
+    case "denied":
+      return "declined";
+    case "invalid":
+      return "invalid";
+    // v26's cancelled is the turn's cancel settling the request; ignored is the one eve dropped for a message (v27 withdraws it).
+    case "cancelled":
+      return "interrupted";
+    default:
+      return "withdrawn";
+  }
+}
+function signInRequest(data) {
+  const auth = isRecord(data.authorization) ? data.authorization : {};
+  const name = str(data.name) ?? "sign-in";
+  const url = str(auth.url);
+  const principal = isRecord(data.principal) && typeof data.principal.type === "string" ? { type: data.principal.type, ...str(data.principal.id) === void 0 ? {} : { id: data.principal.id }, ...str(data.principal.issuer) === void 0 ? {} : { issuer: data.principal.issuer } } : void 0;
+  return {
+    kind: "sign-in",
+    prompt: str(data.description) ?? `Sign in to ${name}.`,
+    ...url === void 0 ? {} : { link: { url } },
+    signIn: compact({ name, displayName: str(auth.displayName), url, userCode: str(auth.userCode), expiresAt: str(auth.expiresAt), instructions: str(auth.instructions), callbackUrl: str(data.webhookUrl), grant: str(data.grant), principal })
+  };
+}
+function signInOutcome(outcome) {
+  return outcome === "authorized" ? "accepted" : outcome === "declined" ? "declined" : outcome === "timed-out" ? "expired" : "failed";
+}
+function usageOf(usage) {
+  return {
+    inputTokens: num2(usage.inputTokens),
+    outputTokens: num2(usage.outputTokens),
+    cacheReadTokens: num2(usage.cacheReadTokens),
+    cacheWriteTokens: num2(usage.cacheWriteTokens),
+    ...typeof usage.costUsd === "number" ? { costUsd: usage.costUsd } : {}
+  };
+}
+function errorOf(data) {
+  return { code: str(data.code) ?? "unknown", message: str(data.message) ?? "Unknown error.", ...str(data.name) === void 0 ? {} : { name: data.name } };
+}
+var compact = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== void 0));
+var str = (value) => typeof value === "string" ? value : void 0;
+var num2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// ../../lib/session-stream.mjs
+async function* readSessionLines(body, startIndex) {
+  let line = startIndex;
+  let lastAt = null;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const text = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!text) continue;
+      let record;
+      try {
+        record = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      const read = lineOf(record, lastAt);
+      if (read.kind === "skip") continue;
+      if (read.kind === "position") {
+        line = read.next;
+        continue;
+      }
+      if (read.kind === "signal") {
+        yield { signal: read.signal, line };
+        if (read.signal === "ended") return;
+        continue;
+      }
+      if (read.at) lastAt = read.at;
+      yield { line, at: read.at ?? lastAt, facts: read.facts, progress: read.progress, v26: read.v26 };
+      line++;
+    }
+  }
+}
+function lineOf(record, lastAt = null) {
+  if (!record || typeof record !== "object") return { kind: "skip" };
+  if (typeof record.$eve === "string") {
+    if (record.$eve === "position" && Number.isInteger(record.next)) return { kind: "position", next: record.next };
+    if (record.$eve === "stream.lease-ended") return { kind: "signal", signal: "lease-ended" };
+    if (record.$eve === "stream.ended") return { kind: "signal", signal: "ended" };
+    return { kind: "skip" };
+  }
+  if (Array.isArray(record.facts)) {
+    return { kind: "line", at: typeof record.at === "string" ? record.at : lastAt, facts: record.facts.filter(isFact), progress: false };
+  }
+  if (record.progress && isFact(record.progress)) {
+    return { kind: "line", at: lastAt, facts: [record.progress], progress: true };
+  }
+  if (typeof record.type === "string") {
+    const translated = factsOfV26(record);
+    return { kind: "line", at: typeof record.meta?.at === "string" ? record.meta.at : lastAt, facts: translated.facts, progress: translated.progress, v26: record };
+  }
+  return { kind: "skip" };
+}
+function isFact(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string";
+}
+
+// ../../hosted-hub/src/dispatch/stream.ts
+var StreamError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+var IDLE_MS = 15e3;
+async function* streamLines(eve, sessionId, o) {
+  const fetchFn = o.fetch ?? fetch, idleMs = o.idleMs ?? IDLE_MS;
+  let next = o.startIndex, reopens = o.reopens ?? 3;
+  for (; ; ) {
+    const query = new URLSearchParams({ startIndex: String(next) });
+    if (o.follow) query.set("streamControlVersion", "1");
+    else {
+      query.set("follow", "false");
+      query.set("includeTailIndex", "1");
+    }
+    const idle = new AbortController(), signal = o.signal ? AbortSignal.any([o.signal, idle.signal]) : idle.signal;
+    let timer = setTimeout(() => idle.abort(), idleMs);
+    const quiet = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => idle.abort(), idleMs);
+    };
+    let renewed = false;
+    try {
+      const res = await fetchFn(`${eve.url}/v1/session/${encodeURIComponent(sessionId)}/stream?${query}`, { headers: eve.headers, cache: "no-store", redirect: "error", signal }).catch((error) => {
+        if (o.signal?.aborted || idle.signal.aborted) return void 0;
+        throw error;
+      });
+      if (o.signal?.aborted) return;
+      if (res && (!res.ok || !res.body)) {
+        const text = await res.text().catch(() => "");
+        let code;
+        try {
+          code = JSON.parse(text).error?.code ?? JSON.parse(text).code;
+        } catch {
+        }
+        throw new StreamError(res.status, code, `eve answered ${res.status} to the stream of ${sessionId}${code ? ` (${code})` : ""}`);
+      }
+      if (res) {
+        try {
+          for await (const record of readSessionLines(watched(res.body, quiet), next)) {
+            if ("signal" in record) {
+              if (record.signal === "ended") return;
+              next = record.line;
+              renewed = true;
+              break;
+            }
+            yield record;
+            next = record.line + 1;
+            reopens = o.reopens ?? 3;
+          }
+        } catch (error) {
+          if (o.signal?.aborted) return;
+          if (!idle.signal.aborted) throw error;
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+    if (renewed) continue;
+    if (!o.follow || reopens-- <= 0) return;
+  }
+}
+async function* watched(body, onBytes) {
+  for await (const chunk of body) {
+    onBytes();
+    yield chunk;
+  }
+}
+
+// ../../hosted-hub/runner/stage.ts
+import { cpSync, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+import { join as join2 } from "node:path";
+
+// ../../hosted-hub/src/plain.ts
+var Plain = class extends Error {
+  plain = true;
+};
+
+// ../../hosted-hub/runner/stage.ts
+var SetupFailure = class extends Plain {
+};
+function install(pnpm, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(pnpm, ["install", "--no-frozen-lockfile"], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const keep = (chunk) => process.stderr.write(chunk);
+    child.stdout.on("data", keep);
+    child.stderr.on("data", keep);
+    child.once("error", (error) => {
+      console.error("pnpm install could not start:", error.message);
+      reject(new SetupFailure("The bots' dependencies could not be installed: pnpm didn't start. Check that pnpm is installed, then retry.", { cause: error }));
+    });
+    child.once("exit", (code, signal) => {
+      if (code === 0) return resolve2();
+      console.error(`pnpm install failed (${signal ? `signal ${signal}` : `exit ${code}`})`);
+      reject(new SetupFailure("The bots' dependencies could not be installed. The log has pnpm's output."));
+    });
+  });
+}
+var SKIP = /* @__PURE__ */ new Set(["node_modules", ".eve", ".env", ".git"]);
+var WORKSPACE_YAML = "packageExtensions:\n  nitro:\n    dependencies:\n      pathe: ^2.0.3\nallowBuilds:\n  tree-sitter-bash: false\n";
+async function stageLocal(workspace, dir, pnpm) {
+  mkdirSync2(dir, { recursive: true });
+  for (const bot of readdirSync2(join2(workspace, "agents"))) {
+    const staged = join2(dir, "agents", bot);
+    if (!existsSync2(staged)) continue;
+    for (const entry of readdirSync2(staged)) if (!SKIP.has(entry)) rmSync2(join2(staged, entry), { recursive: true, force: true });
+  }
+  cpSync(join2(workspace, "agents"), join2(dir, "agents"), { recursive: true, force: true, filter: (p) => !SKIP.has(p.split("/").at(-1)) });
+  rmSync2(join2(dir, "lib"), { recursive: true, force: true });
+  if (existsSync2(join2(workspace, "lib"))) cpSync(join2(workspace, "lib"), join2(dir, "lib"), { recursive: true, filter: (p) => !SKIP.has(p.split("/").at(-1)) });
+  const config = join2(dir, "hub.workspace.json");
+  if (existsSync2(config) || (() => {
+    try {
+      return lstatSync(config).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  })()) rmSync2(config);
+  symlinkSync(join2(workspace, "hub.workspace.json"), config);
+  const source = JSON.parse(readFileSync2(join2(workspace, "package.json"), "utf8"));
+  const pkg = { name: "hub-local-bots", private: true, type: "module", dependencies: source.dependencies };
+  const manifest = `${JSON.stringify(pkg, null, 2)}
+`;
+  const want = `${manifest}${WORKSPACE_YAML}`;
+  const installed = join2(dir, "node_modules", ".hub-local-package.json");
+  writeFileSync2(join2(dir, "package.json"), manifest);
+  writeFileSync2(join2(dir, "pnpm-workspace.yaml"), WORKSPACE_YAML);
+  writeFileSync2(join2(dir, ".npmrc"), "registry=https://registry.npmjs.org/\n");
+  if (!existsSync2(installed) || readFileSync2(installed, "utf8") !== want) {
+    for (const lock of ["pnpm-lock.yaml", "node_modules/.pnpm/lock.yaml"]) rmSync2(join2(dir, lock), { force: true });
+    await install(pnpm, dir);
+    writeFileSync2(installed, want);
+  }
+}
+
+// ../../hosted-hub/runner/check.ts
+var QUERY = "reply with the single word: pong";
+async function checkLocalBots(checkout, { pnpm = "pnpm", node = process.execPath, portBase = 4700, timeoutMs = 18e4 } = {}) {
+  const workspace = resolve(checkout);
+  const { agents = [] } = JSON.parse(readFileSync3(join3(workspace, "hub.workspace.json"), "utf8"));
+  const local = agents.filter((a) => a.runsOn === "local").map((a, i) => ({ name: a.name, port: portBase + i }));
+  const dir = mkdtempSync(join3(tmpdir(), "hub-runner-check-"));
+  const logs = [];
+  const supervisor = createSupervisor({
+    root: dir,
+    stateDir: join3(dir, ".runner"),
+    command: [node, join3(dir, "node_modules", "eve", "bin", "eve.js")],
+    env: (agent) => ({ ...cleanEnv(process.env), HUB_AGENT: agent.name, HUB_WORKSPACE: workspace, HUB_SANDBOX_SERVICES: "none", ROSTER_MODELS: "mock" }),
+    log: (line) => logs.push(line),
+    warn: (line) => logs.push(line)
+  });
+  const failed = (what) => new Error(`${what}
+${logs.join("\n")}`);
+  try {
+    await stageLocal(workspace, dir, pnpm);
+    await supervisor.startAll(local);
+    const answered = [];
+    for (const agent of local) {
+      if (!await supervisor.waitUp(agent, timeoutMs)) throw failed(`${agent.name} didn't come up`);
+      answered.push({ bot: agent.name, reply: await ask({ url: `http://127.0.0.1:${agent.port}/eve`, headers: { "content-type": "application/json", "x-roster-user": "check" } }, timeoutMs).catch((e) => {
+        throw failed(`${agent.name} didn't answer: ${e.message}`);
+      }) });
+    }
+    return answered;
+  } finally {
+    await supervisor.stopAll();
+    rmSync3(dir, { recursive: true, force: true });
+  }
+}
+async function ask(eve, timeoutMs) {
+  const sessionId = await createSession(fetch, eve, "check");
+  const signal = AbortSignal.timeout(timeoutMs);
+  for (; ; ) {
+    const res = await fetch(`${eve.url}/v1/session/${encodeURIComponent(sessionId)}`, { method: "POST", headers: eve.headers, signal, body: JSON.stringify({ message: [{ type: "text", text: QUERY }], idempotencyKey: "check", turnPolicy: "steer" }) });
+    if (res.ok) break;
+    const body = await res.text();
+    if (res.status !== 409 || !body.includes("session_not_ready")) throw new Error(`send: HTTP ${res.status} ${body.slice(0, 300)}`);
+    await delay(250, void 0, { signal });
+  }
+  let reply = "";
+  for await (const { facts } of streamLines(eve, sessionId, { startIndex: 0, follow: true, signal })) {
+    for (const fact2 of facts) {
+      if (fact2.type === "content.completed" && fact2.data?.phase === "reply") reply += fact2.data.value ?? "";
+      if (fact2.type === "turn.settled") {
+        if (fact2.data?.outcome !== "completed" || !reply) throw new Error(`the turn ended ${fact2.data?.outcome} with reply ${JSON.stringify(reply)}`);
+        return reply;
+      }
+    }
+  }
+  throw new Error("the stream ended before the turn settled");
+}
+export {
+  QUERY,
+  checkLocalBots
+};