@agentpulselabs/cli-plugin-pulse 1.0.0 → 1.1.3

package/src/runner/facade.js

@@ -0,0 +1,876 @@
+// The local hub API on 127.0.0.1:8890, served by the Pulse runner (design §7, D11). A port of agents-hub
+// server/http.mjs at 6b2fb0b: the same routes, guards, auth and SSE over the same ported core, with these changes:
+// - every write runs in one capture transaction, so the hub rows and their outbox commands commit together, and it
+//   commits only while its client is still connected and inside its budget (H2); the answer goes out right after;
+// - `/` redirects to Pulse (an offline status page when the cloud is out of reach); the hub UI is retired;
+// - new routes: POST /hook (handleHook, verbatim), /api/legacy/* (the old hub.mjs subcommands), /runner/health and
+//   /runner/metrics;
+// - the manager, the wake sweep and the scheduled nudge run only while this runner holds the user's manager lease;
+// - Pulse 1.1.1: one bus identity per session (busIdentity.js: aliases bound by the hook, mail routed to the session,
+//   `GET /bus/who`) and honest delivery states (deliveryStates.js: `delivery` in /bus/publish and /bus/messages,
+//   `GET /bus/status`, the manager's FYIs read or skipped, undeliverable notices).
+import http from 'node:http';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { authenticate, bindPrincipal, setAuthCookie } from '../hub/core/auth.mjs';
+import { changeTracker } from '../hub/core/changes.mjs';
+import { withTx } from '../hub/core/db.mjs';
+import { ADDRESS, MESSAGE_ID, ONLINE_MS } from '../hub/core/ids.mjs';
+import { STOPPED_MS, requestWake, scheduledNudge, sweepWakes } from '../hub/core/wake.mjs';
+import { isBusy } from '../hub/core/ticks.mjs';
+import { handleHook } from '../hub/hooks/hub-bridge.mjs';
+import { defaultDrivers, diagnoseClaude } from '../hub/runners/drivers.mjs';
+import { createRunner } from '../hub/workers/runner.mjs';
+import { readTaskBrief } from '../hub/lib/brief.mjs';
+import { decisionPost, parsePosts } from '../hub/lib/channels.mjs';
+import { STEP_IDS, auditPost, movePost, overrideHolds, overrideKey, overrideText, statusRequest, stepHolds, withOverride, workMoved } from '../hub/lib/status.mjs';
+import { askDetail, channelParticipant, hasChatInbox, listChannels, participantPost, participantThread, postToProject, projectMessages, taskMessages } from '../hub/lib/chat.mjs';
+import { findAgentQuery } from '../hub/lib/transcripts.mjs';
+import { watchTranscripts } from '../hub/lib/transcript-feed.mjs';
+import { HUB, acceptDelivery, keepAwakeStatus, readSettings, validSettings, writeSettings } from '../hub/lib/store.mjs';
+import { createManager } from '../hub/workers/manager.mjs';
+import { NOBODY, aliasesFor } from '../hub/lib/me.mjs';
+import { personaUsernames, voiceFor } from '../hub/lib/personas.mjs';
+import { projectDeliveries } from '../hub/projections/deliveries.mjs';
+import { projectGraph } from '../hub/projections/graph.mjs';
+import { execFileBounded } from '../lib/subprocess.js';
+import { createBusIdentity, routedMessaging } from './busIdentity.js';
+import { createChannelDiscipline } from './channelDiscipline.js';
+import { createDeliveryStates } from './deliveryStates.js';
+import { statusPage } from './statusPage.js';
+
+const WORKSPACE = path.resolve(HUB, '..');
+const CHANNEL_ROOTS = ['AgentPulseApps', 'Google_Cloud'].map((d) => path.join(WORKSPACE, d));
+const HOURS = [1, 3, 6, 12, 24, 72, 168];
+const CACHE_MS = 4000;
+const CHANGE_DEBOUNCE_MS = 600;
+/** Steady writes (heartbeats every few hundred ms) keep restarting the debounce; a change still goes out this soon. */
+const CHANGE_MAX_WAIT_MS = 2000;
+/** A graph read re-registers the user at most this often: often enough to stay online, rarely enough not to wake the change feed on every read. */
+const USER_SEEN_MS = ONLINE_MS / 3;
+const CHAT_CHANNELS_MS = 48 * 3600e3;
+const CHAT_HISTORY_MS = 7 * 24 * 3600e3;
+const MAX_BODY_BYTES = 20e3;
+/** The hook client sends only the fields handleHook reads; a long agent answer still fits. */
+const HOOK_BODY_BYTES = 64e3;
+/** The hook client gives up after 2 s; the runner rolls back past this, so it never commits mail nobody saw. */
+export const HOOK_BUDGET_MS = 1500;
+/** Other writes: well inside the 8 s the CLI client waits. */
+export const WRITE_BUDGET_MS = 5000;
+const LISTEN_HEARTBEAT_MS = 5000;
+const LOCAL_HOST = /^(127\.0\.0\.1|localhost)(:\d+)?$/;
+const LOCAL_ORIGIN = /^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/;
+const NO_FRAME = { 'x-frame-options': 'DENY', 'content-security-policy': "frame-ancestors 'none'", 'x-content-type-options': 'nosniff' };
+
+const sendJson = (res, body, code = 200, extra = {}) => {
+  res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store', ...NO_FRAME, ...extra });
+  res.end(JSON.stringify(body));
+};
+
+function trustedWrite(req) {
+  const origin = req.headers.origin;
+  if (origin && !LOCAL_ORIGIN.test(origin)) return false;
+  const site = req.headers['sec-fetch-site'];
+  if (site && site !== 'same-origin' && site !== 'none') return false;
+  return String(req.headers['content-type'] || '').startsWith('application/json');
+}
+
+function readBody(req, res, done, maxBytes = MAX_BODY_BYTES) {
+  req.setEncoding('utf8');
+  let raw = '';
+  let bytes = 0;
+  let over = false;
+  req.on('data', (c) => {
+    if (over) return;
+    bytes += Buffer.byteLength(c);
+    if (bytes <= maxBytes) { raw += c; return; }
+    over = true;
+    sendJson(res, { error: 'message too large' }, 413, { connection: 'close' });
+    req.pause();
+  });
+  req.on('end', () => {
+    if (over) return;
+    let body;
+    try { body = JSON.parse(raw || '{}'); } catch { sendJson(res, { error: 'bad json' }, 400); return; }
+    if (!body || typeof body !== 'object' || Array.isArray(body)) { sendJson(res, { error: 'bad json' }, 400); return; }
+    try { done(body); } catch (e) { console.error(`write failed: ${e && e.stack ? e.stack : e}`); if (!res.headersSent) sendJson(res, { error: 'server error' }, 500); }
+  });
+}
+
+/** A write that may not commit: its client left, or it ran past its budget. Nothing it did is kept. */
+class Refused extends Error {}
+
+/** The Cursor session a `bus listen`, `ack` or `reply` ran in (the CLI sends CURSOR_CONVERSATION_ID), or null. */
+const callerSession = (body) => (ADDRESS.test(String(body.session || '')) ? body.session : null);
+
+/** A listen or ack as an alias a live session holds, from anyone but that session: refused before it takes anything. */
+const heldAnswer = (alias, held) => ({
+  error: 'held', holder: held.session, idleMin: held.idleMin,
+  message: `${alias} is held by live session ${held.session}, which gets its mail. Only that session can listen or reply as ${alias}.`,
+});
+
+/** Pulse 1.1.2 (E1): mail to an address the bus doesn't know is refused, with the closest ones it does. */
+const unknownAddress = (address, didYouMean) => ({
+  error: 'E_UNKNOWN_ADDRESS', address, didYouMean,
+  message: `agent/${address} is not a known session id or bound alias, so nobody could ever read this.${didYouMean.length ? ` Did you mean ${didYouMean.map((d) => `agent/${d.address}`).join(', ')}?` : ''} A session is known once it has run a tool; a nickname needs \`bus register --as <nickname>\` from inside that session. If it is a session or alias on another machine, retry in a minute: its presence takes about 30 s to reach this one.`,
+});
+
+/** The outbox is at its cap (§6.2): the write is refused, said so, and never spooled (507). */
+const backlogged = (e) => e && e.code === 'pulse_backlog';
+const BACKLOG = { error: 'pulse_backlog' };
+
+/** The request stream itself is destroyed once its body is read; what matters is the socket the answer goes back on. */
+const connected = (req, res) => {
+  const socket = res.socket || req.socket;
+  return !!socket && !socket.destroyed && !res.writableEnded && !res.closed;
+};
+
+/** Capture over a plain hub (tests that serve a bare openHub): the same transaction and guard, no outbox. */
+export function plainCapture(db) {
+  return {
+    tx: (fn, { guard = null, label = 'write' } = {}) => withTx(db, () => { const out = fn(); if (guard) guard(); return out; }, label),
+    applying: (fn) => fn(),
+    pump: () => 0,
+  };
+}
+
+const BRIEF_CACHE_MS = 30e3;
+const briefCache = new Map();
+
+export function channelFileFor(key, roots = CHANNEL_ROOTS) {
+  const m = String(key || '').match(/^([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/);
+  if (!m || m[1].startsWith('.') || m[2].startsWith('.')) return null;
+  for (const root of roots) {
+    const file = path.join(root, m[1], '.agents', m[2], 'channel.md');
+    try {
+      const st = fs.lstatSync(file);
+      if (!st.isFile()) continue;
+      const realRoot = fs.realpathSync(root);
+      if (fs.realpathSync(file) !== path.join(realRoot, m[1], '.agents', m[2], 'channel.md')) continue;
+      return file;
+    } catch { /* not here */ }
+  }
+  return null;
+}
+
+function taskBriefFor(key, roots) {
+  const hit = briefCache.get(key);
+  if (hit && Date.now() - hit.at < BRIEF_CACHE_MS) return hit.body;
+  const file = channelFileFor(key, roots);
+  if (!file) return null;
+  const fromFiles = readTaskBrief(file);
+  const thin = !fromFiles || !fromFiles.sections.some((s) => s.body && s.body.trim());
+  const body = thin ? (readTaskBrief(file, { query: findAgentQuery(key) }) || fromFiles || { title: null, source: null, sections: [] }) : fromFiles;
+  if (briefCache.size > 200) briefCache.clear();
+  briefCache.set(key, { at: Date.now(), body });
+  return body;
+}
+
+/** How many posts a channel holds now: the position of the one just appended. */
+const postsIn = (file) => parsePosts(fs.readFileSync(file, 'utf8'), Date.now()).length;
+
+/** Append to a channel file checked by channelFileFor; refuses if the path was swapped between the check and the open. */
+export function appendNoFollow(file, text) {
+  const fd = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_NOFOLLOW);
+  try {
+    const opened = fs.fstatSync(fd);
+    const real = fs.statSync(fs.realpathSync(file));
+    if (!opened.isFile() || opened.ino !== real.ino || opened.dev !== real.dev) throw new Error(`channel file moved: ${file}`);
+    fs.writeSync(fd, text);
+  } finally { fs.closeSync(fd); }
+}
+
+function collectWorker() {
+  const worker = new Worker(new URL('../hub/lib/collect-worker.mjs', import.meta.url));
+  const waiting = new Map();
+  let seq = 0;
+  worker.on('message', ({ id, body, error }) => {
+    const w = waiting.get(id);
+    waiting.delete(id);
+    if (w) { if (error) w.reject(new Error(error)); else w.resolve(body); }
+  });
+  worker.on('error', (e) => { console.error(`collector crashed: ${e && e.stack ? e.stack : e}`); process.exit(1); });
+  return (hours, managerView, aliases, { discoveryEpoch } = {}) => {
+    const id = ++seq;
+    const running = new Promise((resolve, reject) => waiting.set(id, { resolve, reject }));
+    worker.postMessage({ id, hours, managerView, aliases, discoveryEpoch });
+    return running;
+  };
+}
+
+function collector(run) {
+  const cache = new Map();
+  /** Bumped by clear() and reproject(): a collect started before a change must not cache its older body. */
+  let generation = 0;
+  /** Bumped by clear() only: the collector may reuse a discovery pass from the same epoch (workers/collector.mjs). */
+  let discoveryEpoch = 0;
+  return {
+    graph(hours, managerView, aliases = []) {
+      const hit = cache.get(hours);
+      if (hit && hit.body && Date.now() - hit.at < CACHE_MS) return Promise.resolve(hit.body);
+      if (hit && hit.running) return hit.running;
+      const started = generation;
+      const running = Promise.resolve(run(hours, managerView, aliases, { discoveryEpoch }))
+        .then((body) => { if (started === generation) cache.set(hours, { at: Date.now(), body }); return body; })
+        .catch((e) => { if (started === generation) cache.delete(hours); throw e; });
+      cache.set(hours, { ...(hit || {}), running });
+      return running;
+    },
+    clear() { generation++; discoveryEpoch++; cache.clear(); },
+    /** Presence moved and nothing else: refresh the bodies without a new discovery pass. */
+    reproject() { generation++; cache.clear(); },
+  };
+}
+
+/** A runner.db write; it becomes a `hub` change only when the database holds news (core/changes.mjs). */
+const DB_WRITE = 'db-write';
+
+function watchRecursive(dir, onFile, onError) {
+  return fs.watch(dir, { recursive: true }, (e, f) => { if (f) onFile(String(f)); }).on('error', onError);
+}
+
+function changeFeed(onChange, { stateDir, dbFile, channelRoots, transcriptsDir, hubChanged, watchDir }) {
+  const clients = new Set();
+  const pending = new Set();
+  let timer = null;
+  let firstPendingAt = null;
+  const dbNews = () => { try { return hubChanged(); } catch (e) { console.error(`change check failed: ${e.message}`); return 'hub'; } };
+  const flush = () => {
+    firstPendingAt = null;
+    if (pending.delete(DB_WRITE)) { const news = dbNews(); if (news) pending.add(news); }
+    if (pending.has('hub')) pending.delete('presence');
+    const kinds = [...pending];
+    pending.clear();
+    if (!kinds.length) return;
+    onChange(kinds);
+    const msg = `event: change\ndata: ${JSON.stringify({ kinds, at: Date.now() })}\n\n`;
+    for (const res of clients) res.write(msg);
+  };
+  const notify = (kind) => {
+    pending.add(kind);
+    clearTimeout(timer);
+    firstPendingAt ??= Date.now();
+    timer = setTimeout(flush, Math.min(CHANGE_DEBOUNCE_MS, Math.max(0, firstPendingAt + CHANGE_MAX_WAIT_MS - Date.now())));
+  };
+  const watchers = [];
+  const watch = (dir, kindOf) => {
+    const failed = (err) => console.error(`cannot watch ${dir}: ${err.message}; that part falls back to polling`);
+    try { watchers.push(watchDir(dir, (f) => { const kind = kindOf(f); if (kind) notify(kind); }, failed)); }
+    catch (err) { failed(err); }
+  };
+  const dbName = path.basename(dbFile || 'hub.db');
+  for (const root of channelRoots) watch(root, (f) => (/\.agents[\\/][^\\/]+[\\/](channel|brief)\.md$/.test(f) ? 'channels' : null));
+  watch(stateDir, (f) => (/(events\.jsonl|requests|chat[\\/]|inbox[\\/]|bus[\\/]|accepted\.json|personas\.json)/.test(f) ? 'hub' : null));
+  if (dbFile) watch(path.dirname(dbFile), (f) => (f.startsWith(dbName) ? DB_WRITE : null));
+  if (transcriptsDir) watchTranscripts(transcriptsDir, () => notify('agents'));
+  const keepAlive = setInterval(() => { for (const res of clients) res.write(': keep-alive\n\n'); }, 25e3);
+  keepAlive.unref();
+  return {
+    attach(req, res) {
+      res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive', ...NO_FRAME });
+      res.write(`event: hello\ndata: ${JSON.stringify({ at: Date.now() })}\n\n`);
+      clients.add(res);
+      req.on('close', () => clients.delete(res));
+    },
+    /** A write that landed here or a sync page that was applied: same as a hub.db file change before. */
+    dbWrite: () => notify(DB_WRITE),
+    notify,
+    close() { clearTimeout(timer); clearInterval(keepAlive); for (const w of watchers) w.close(); for (const res of clients) res.end(); },
+  };
+}
+
+function settingsOf(hub) {
+  const fromDb = hub.registry.fact('settings', 'hub');
+  const s = fromDb ? validSettings(fromDb) : readSettings();
+  return { ...s, keepAwakeStatus: keepAwakeStatus() };
+}
+
+const hasTable = (db, name) => Boolean(db.prepare("SELECT 1 AS found FROM sqlite_master WHERE type = 'table' AND name = ?").get(name));
+
+/** Without a cloud lease (tests, a bare hub) this runner is the only one, as the local hub was. */
+const SOLE_LEASE = Object.freeze({ held: () => true, view: () => ({ holder: 'local', here: true }), onChange: () => {} });
+
+export function serve({
+  hub, capture = plainCapture(hub.db), port = 8890, listenHost = '127.0.0.1', stateDir = path.join(HUB, 'state'), dbFile = null,
+  enableCollector = true, enableManager = true, collect = null, channelRoots = CHANNEL_ROOTS,
+  transcriptsDir = path.join(os.homedir(), '.cursor', 'projects'), watchDir = watchRecursive, identity = null,
+  lease = SOLE_LEASE, pulseUrl = null, health = () => ({ state: 'online' }), metrics = () => ({}), drivers = null,
+  hookBudgetMs = HOOK_BUDGET_MS, writeBudgetMs = WRITE_BUDGET_MS, onWrite = () => {}, managerOptions = {}, workspaceRoot = WORKSPACE,
+  discipline: disciplineOptions = {},
+} = {}) {
+  const me = () => {
+    const m = identity ? identity.current() : NOBODY;
+    return m === NOBODY ? NOBODY : { ...m, aliases: aliasesFor(m, personaUsernames()) };
+  };
+  const graphs = enableCollector ? collector(collect || collectWorker()) : { graph: async () => ({ nodes: [], links: [], events: [], deliveries: [], agents: [], totals: {} }), clear() {}, reproject() {} };
+  const caches = { clear: () => graphs.clear() };
+  const feed = enableCollector
+    ? changeFeed((kinds) => (kinds.every((k) => k === 'presence') ? graphs.reproject() : graphs.clear()), { stateDir, dbFile, channelRoots, transcriptsDir, hubChanged: changeTracker(hub.db), watchDir })
+    : { attach(req, res) { res.writeHead(200); res.end(); }, dbWrite() {}, notify() {}, close() {} };
+  if (identity) {
+    identity.listen(() => { graphs.clear(); feed.notify('hub'); });
+    identity.refresh();
+  }
+  const bus = createBusIdentity(hub);
+  const delivery = createDeliveryStates(hub, bus);
+  const { sweepMs: disciplineSweepMs = 60e3, ...thresholds } = disciplineOptions;
+  const discipline = createChannelDiscipline(hub, {
+    channelRoots, workspaceRoot, append: appendNoFollow, ...thresholds,
+    publish: (message) => hub.messaging.publish(message, hub.registry.directory()),
+  });
+  const manager = enableManager
+    ? createManager({ hub, state: stateDir, onChange: () => graphs.clear(), held: () => lease.held(), fyi: (m) => delivery.managerFyi(m), ...managerOptions })
+    : { start() {}, stop() {}, view() { return { state: 'offline', online: false, pending: 0 }; } };
+  /** The manager's status, with the DONE and STATUS posts it has read (F2). */
+  const managerView = () => ({ ...manager.view(), reports: delivery.reports() });
+  const holder = `server-${process.pid}`;
+  let serverLease = { error: 'pending' };
+  for (let i = 0; i < 12; i++) {
+    serverLease = hub.leases.acquire('server', holder, { ttlMs: 30e3, force: i >= 11 });
+    if (!serverLease.error) break;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+  }
+  if (serverLease.error) console.error(`another hub server holds the lease (${serverLease.holder}); taking over`);
+  const timers = [];
+  const every = (ms, fn) => { const t = setInterval(fn, ms); t.unref(); timers.push(t); };
+  if (serverLease.token) {
+    every(10e3, () => { try { hub.leases.renew('server', serverLease.token, { ttlMs: 30e3 }); } catch (e) { console.error(`server lease renewal failed: ${e.message}`); } });
+  }
+  const releaseLease = () => { if (serverLease.token) { try { hub.leases.release('server', serverLease.token); } catch { /* closing */ } } };
+  const wrote = () => { feed.dbWrite(); onWrite(); };
+  /** The manager, the wake sweep and the scheduled nudge belong to the runner holding the user's manager lease (Q9). */
+  const leaseHeld = () => lease.held();
+  if (enableManager) {
+    if (leaseHeld()) manager.start();
+    lease.onChange((held) => { if (held) manager.start(); else manager.stop(); });
+    every(60e3, () => {
+      if (!leaseHeld()) return;
+      try { if (capture.tx(() => sweepWakes(hub), { label: 'wake sweep' }).length) { caches.clear(); wrote(); } } catch (e) { console.error(`wake sweep failed: ${e.message}`); }
+      try {
+        if (capture.tx(() => delivery.settleNudges() + delivery.bounce().length, { label: 'delivery sweep' })) { caches.clear(); wrote(); }
+      } catch (e) { console.error(`delivery sweep failed: ${e.message}`); }
+    });
+    every(disciplineSweepMs, () => {
+      if (!leaseHeld()) return;
+      try {
+        if (capture.tx(() => discipline.sweep().length, { label: 'stale sweep' })) { caches.clear(); wrote(); }
+      } catch (e) { console.error(`stale sweep failed: ${e.message}`); }
+    });
+  }
+  const runner = createRunner({ hub, drivers: drivers || defaultDrivers(), workspaceRoot: WORKSPACE, onChange: () => { graphs.clear(); wrote(); } });
+  if (enableManager) runner.begin();
+  if (enableManager) every(30e3, () => {
+    if (!leaseHeld()) return;
+    try {
+      const nudge = () => scheduledNudge(hub, {
+        everyMin: settingsOf(hub).wake.nudgeEveryMin, skip: (last) => delivery.postedSince(last), released: () => delivery.settledNudgeRecipients(),
+      });
+      if (capture.tx(nudge, { label: 'scheduled nudge' })) { caches.clear(); wrote(); }
+    } catch (e) { console.error(`scheduled nudge failed: ${e.message}`); }
+  });
+
+  const registeredAt = hasTable(hub.db, 'pulse_registered')
+    ? hub.db.prepare('INSERT INTO pulse_registered (id, at) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET at = excluded.at')
+    : null;
+
+  /**
+   * One write in one capture transaction; the answer is sent only after it committed. An abort that arrives during
+   * the synchronous transaction itself is seen only after COMMIT: that window is one SQLite transaction long.
+   */
+  const commit = (req, res, started, budgetMs, fn) => capture.tx(fn, {
+    guard: () => {
+      if (!connected(req, res)) throw new Refused('client_gone');
+      if (Date.now() - started > budgetMs) throw new Refused('over_budget');
+    },
+  });
+
+  const writeRoute = (req, res, started, handler) => {
+    let answer = null;
+    const send = (body, code = 200, extra = {}) => { answer = [body, code, extra]; };
+    try {
+      commit(req, res, started, writeBudgetMs, () => handler(send));
+    } catch (e) {
+      if (backlogged(e)) { if (connected(req, res)) sendJson(res, BACKLOG, 507); return undefined; }
+      if (!(e instanceof Refused)) throw e;
+      if (connected(req, res)) sendJson(res, { error: 'hub busy, try again' }, 503);
+      return undefined;
+    }
+    wrote();
+    if (answer) sendJson(res, ...answer);
+    return undefined;
+  };
+
+  /** Each hook event's field names, once per event per runner: the real Cursor payload's shape, never its values. */
+  const shapesSeen = new Set();
+  const noteShape = (input) => {
+    const keys = input && input._keys;
+    const event = String(input && input.hook_event_name);
+    if (!keys || shapesSeen.has(event)) return;
+    shapesSeen.add(event);
+    try {
+      fs.appendFileSync(path.join(stateDir, 'hook-shapes.jsonl'), `${JSON.stringify({ at: Date.now(), event, keys })}\n`, { mode: 0o600 });
+    } catch { /* a diagnostic only */ }
+  };
+
+  /**
+   * One hook event, in the hook's transaction: the session's activity, any alias its Shell command registered or
+   * listened as, what its earlier hooks showed it now read, then handleHook (verbatim) over the session's whole inbox:
+   * its own address and its aliases. A binding's result is told to the session in the same answer. Pulse 1.1.2: the
+   * delivery-discipline checks (channelDiscipline.js) run on every event; a `preToolUse` answer carries only E5's
+   * permission decision, since Cursor blocks a call whose answer doesn't match that hook's schema.
+   */
+  const answerHook = (input) => {
+    const id = input && input.conversation_id;
+    if (!input || !input.hook_event_name || !ADDRESS.test(String(id || '')) || id === 'user' || id === 'manager') return handleHook(input, hub);
+    noteShape(input);
+    const at = Date.now();
+    const previousHook = bus.sawHook(input, at);
+    const bound = bus.bindFromHook(input, at);
+    const addresses = bus.addressesOf(id);
+    delivery.readOnHook(addresses, { at, previousHook });
+    const out = handleHook(input, { ...hub, messaging: routedMessaging(hub.messaging, addresses) });
+    let checked = { deny: null, notices: [] };
+    try {
+      checked = discipline.onHook(input, at);
+    } catch (e) {
+      console.error(`discipline check failed open on ${input.hook_event_name}: ${e && e.message ? e.message : e}`);
+    }
+    if (input.hook_event_name === 'preToolUse') return checked.deny || {};
+    const notice = [bus.notices(bound, id), ...checked.notices].filter(Boolean).join('\n\n');
+    return notice ? { ...out, additional_context: [out.additional_context, notice].filter(Boolean).join('\n\n') } : out;
+  };
+
+  const routes = (req, res, p, url, auth, started) => {
+    if (p === '/' || p === '/index.html') {
+      setAuthCookie(res, hub.token);
+      const h = health();
+      if (pulseUrl && h.state !== 'offline') {
+        res.writeHead(302, { location: pulseUrl, 'cache-control': 'no-store', ...NO_FRAME });
+        return res.end();
+      }
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', ...NO_FRAME });
+      return res.end(statusPage({ health: h, pulseUrl }));
+    }
+    if (p.startsWith('/ui/') || p.startsWith('/shared/')) {
+      res.writeHead(302, { location: '/', 'cache-control': 'no-store', ...NO_FRAME });
+      return res.end();
+    }
+
+    if (!auth) return sendJson(res, { error: 'unauthorized' }, 401);
+
+    if (p === '/runner/health' && req.method === 'GET') return sendJson(res, health());
+    if (p === '/runner/metrics' && req.method === 'GET') return sendJson(res, metrics());
+    if (p === '/api/graph') {
+      const hours = HOURS.includes(Number(url.searchParams.get('hours'))) ? Number(url.searchParams.get('hours')) : 3;
+      const seen = hub.registry.presence('user');
+      if (!seen || Date.now() - seen.last_seen >= USER_SEEN_MS) {
+        capture.tx(() => hub.registry.register({ id: 'user', role: 'USER', name: 'You', topics: ['user'], node_type: 'user' }), { label: 'graph user' });
+        wrote();
+      }
+      return graphs.graph(hours, managerView(), me().aliases).then((body) => sendJson(res, { ...body, settings: { ...settingsOf(hub), me: me() } }))
+        .catch((e) => { console.error(`collect failed: ${e.message}`); if (!res.headersSent) sendJson(res, { error: 'server error' }, 500); });
+    }
+    if (p === '/api/settings' && req.method === 'GET') return sendJson(res, { ...settingsOf(hub), me: me() });
+    if (p === '/api/manager' && req.method === 'GET') return sendJson(res, { ...managerView(), lease: lease.view() });
+    if (p === '/api/stream' && req.method === 'GET') return feed.attach(req, res);
+    if (p === '/bus/messages' && req.method === 'GET') {
+      const since = Number(url.searchParams.get('since')) || 0;
+      const limit = Number(url.searchParams.get('limit')) || 300;
+      return sendJson(res, { messages: delivery.withDelivery(hub.messaging.messages({ since, limit })) });
+    }
+    if (p === '/bus/status' && req.method === 'GET') {
+      const id = String(url.searchParams.get('id') || '');
+      if (!MESSAGE_ID.test(id)) return sendJson(res, { error: 'bad id' }, 400);
+      const found = delivery.status(id);
+      return found ? sendJson(res, found) : sendJson(res, { error: 'no such message' }, 404);
+    }
+    if (p === '/bus/who' && req.method === 'GET') {
+      return sendJson(res, bus.who({ all: url.searchParams.get('all') === '1', minutes: url.searchParams.get('minutes') }));
+    }
+    if (p === '/bus/directory' && req.method === 'GET') {
+      return sendJson(res, { nodes: hub.registry.directory(), registrations: hub.registry.registrations() });
+    }
+    if (p === '/api/task/brief' && req.method === 'GET') {
+      const key = String(url.searchParams.get('key') || '');
+      if (!/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(key)) return sendJson(res, { error: 'no such channel' }, 404);
+      const brief = taskBriefFor(key, channelRoots);
+      return brief ? sendJson(res, brief) : sendJson(res, { error: 'no such channel' }, 404);
+    }
+    if (p === '/api/runs' && req.method === 'GET') return sendJson(res, { runs: runner.list(), drivers: runner.drivers() });
+    if (p === '/api/runs/diagnose' && req.method === 'GET') {
+      diagnoseClaude({ run: execFileBounded }).then((d) => sendJson(res, d)).catch((e) => sendJson(res, { error: e.message }, 500));
+      return undefined;
+    }
+    if (p === '/api/task/ask' && req.method === 'GET') {
+      const key = String(url.searchParams.get('key') || '');
+      const file = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(key) ? channelFileFor(key, channelRoots) : null;
+      if (!file) return sendJson(res, { error: 'no such channel' }, 404);
+      const ref = String(url.searchParams.get('ref') || '');
+      const at = Number(url.searchParams.get('at')) || null;
+      const detail = askDetail(file, { ref: /^[A-Z]?\d+$/.test(ref) ? ref : null, at, aliases: me().aliases });
+      return detail ? sendJson(res, detail) : sendJson(res, { error: 'no open ask in this channel' }, 404);
+    }
+    if (p === '/api/inbox' && req.method === 'GET') {
+      const since = Math.max(Date.now() - 24 * 3600e3, Number(url.searchParams.get('since')) || 0);
+      const messages = hub.messaging.involving('user', since)
+        .filter((m) => m.from !== 'user' && m.to.includes('user') && m.at > since)
+        .map((m) => ({ id: m.id, at: m.at, from: m.from, fromName: m.fromName, type: m.type, body: String(m.body || '').slice(0, 400), replyTo: m.replyTo }));
+      return sendJson(res, { messages, at: Date.now() });
+    }
+    if (p === '/api/chat/channels' && req.method === 'GET') {
+      const dms = hub.conversations.dmPartners();
+      return sendJson(res, { ...listChannels(channelRoots, Date.now() - CHAT_CHANNELS_MS), dms });
+    }
+    if (p === '/api/chat/messages' && req.method === 'GET') {
+      const ch = String(url.searchParams.get('ch') || '');
+      if (ch.startsWith('task:')) {
+        const file = channelFileFor(ch.slice(5), channelRoots);
+        return file ? sendJson(res, { messages: taskMessages(file) }) : sendJson(res, { error: 'no such channel' }, 404);
+      }
+      if (ch.startsWith('project:')) {
+        const messages = projectMessages(channelRoots, ch.slice(8), Date.now() - CHAT_HISTORY_MS);
+        return messages ? sendJson(res, { messages }) : sendJson(res, { error: 'no such channel' }, 404);
+      }
+      if (ch.startsWith('dm:')) {
+        const part = channelParticipant(ch.slice(3));
+        if (part) {
+          const file = channelFileFor(part.key, channelRoots);
+          return file ? sendJson(res, { messages: participantThread(file, part.role) }) : sendJson(res, { error: 'no such person' }, 404);
+        }
+        const dm = hub.conversations.thread(ch.slice(3));
+        return dm ? sendJson(res, dm) : sendJson(res, { error: 'no such person' }, 404);
+      }
+      return sendJson(res, { error: 'no such channel' }, 404);
+    }
+    if (p === '/api/deliveries' && req.method === 'GET') return sendJson(res, projectDeliveries(hub));
+    if (p === '/api/legacy/map' && req.method === 'GET') {
+      return sendJson(res, projectGraph(hub, { hours: Number(url.searchParams.get('hours')) || 6 }));
+    }
+
+    if ((p === '/bus/listen' || p === '/bus/take') && req.method === 'GET') {
+      return sendJson(res, { error: 'use POST' }, 405);
+    }
+
+    if (req.method !== 'POST') return sendJson(res, { error: 'not found' }, 404);
+    if (p === '/hook') {
+      return readBody(req, res, (body) => {
+        let out = {};
+        try {
+          out = commit(req, res, started, hookBudgetMs, () => answerHook(body));
+          wrote();
+        } catch (e) {
+          if (!(e instanceof Refused)) console.error(`hook failed: ${e && e.message ? e.message : e}`);
+          out = {};
+        }
+        if (connected(req, res)) sendJson(res, out);
+      }, HOOK_BODY_BYTES);
+    }
+    return readBody(req, res, (body) => {
+      if (p === '/bus/listen' || p === '/bus/take') {
+        const as = String(body.as || '');
+        const bound = bindPrincipal(auth, as);
+        if (bound.error) return sendJson(res, bound, 403);
+        const box = bus.inboxFor(bound.principal, callerSession(body));
+        if (box.held) return sendJson(res, heldAnswer(bound.principal, box.held), 409);
+        const asked = Number(body.timeout);
+        const timeout = Math.max(0, Math.min(Number.isFinite(asked) ? asked : 25, 30)) * 1000;
+        const pollStarted = Date.now();
+        let beat = pollStarted;
+        const inbox = routedMessaging(hub.messaging, box.addresses);
+        // Re-polls run from a timer, outside readBody's try/catch: a busy database waits for the next poll, anything else answers 503.
+        const poll = () => {
+          if (!connected(req, res)) return undefined;
+          let messages = [];
+          try {
+            messages = commit(req, res, pollStarted, Infinity, () => {
+              if (body.heartbeat === true && Date.now() - beat >= LISTEN_HEARTBEAT_MS) {
+                hub.registry.heartbeat(bound.principal, { event: 'listen' });
+                bus.listened(bound.principal);
+                beat = Date.now();
+              }
+              const got = inbox.claim(bound.principal, { via: 'listen', limit: 20 });
+              if (got.length) inbox.markDelivered(bound.principal, got.map((m) => m.id), { via: 'listen' });
+              return got;
+            });
+          } catch (e) {
+            if (e instanceof Refused) return undefined;
+            if (backlogged(e)) return res.headersSent ? undefined : sendJson(res, BACKLOG, 507);
+            if (!isBusy(e) || Date.now() - pollStarted >= timeout) {
+              console.error(`bus listen for ${bound.principal} failed: ${e.message}`);
+              return res.headersSent ? undefined : sendJson(res, { error: 'hub busy, try again' }, 503);
+            }
+            setTimeout(poll, 250).unref();
+            return undefined;
+          }
+          if (messages.length) wrote();
+          if (messages.length || Date.now() - pollStarted >= timeout) return sendJson(res, { messages, at: Date.now() });
+          setTimeout(poll, 250).unref();
+          return undefined;
+        };
+        return poll();
+      }
+      if (p === '/api/runs') {
+        const parent = typeof body.parent === 'string' && ADDRESS.test(body.parent) ? body.parent : 'manager';
+        const stream = typeof body.stream === 'string' && /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(body.stream) ? body.stream : null;
+        runner.start({ driver: String(body.driver || ''), role: String(body.role || ''), workspace: String(body.workspace || ''), brief: typeof body.brief === 'string' ? body.brief : '',
+          stream, parent, name: typeof body.name === 'string' ? body.name.slice(0, 80) : null, mode: body.mode === 'read' ? 'read' : 'write' })
+          .then((r) => {
+            capture.pump();
+            if (r.error) { console.error(`run refused: ${r.error}`); sendJson(res, r, 400); } else { caches.clear(); wrote(); sendJson(res, r); }
+          })
+          .catch((e) => { console.error(`run start failed: ${e.message}`); sendJson(res, { error: `could not start: ${e.message.slice(0, 200)}` }, 500); });
+        return undefined;
+      }
+      return writeRoute(req, res, started, (send) => {
+        if (p === '/api/message') {
+          const to = (Array.isArray(body.to) ? body.to : [body.to]).filter((x) => typeof x === 'string' && x.length < 200).slice(0, 50);
+          if (!to.length || !['NUDGE', 'STATUS?'].includes(body.type)) return send({ error: 'invalid message' }, 400);
+          const dir = hub.registry.directory();
+          for (const id of to) {
+            hub.messaging.publish({ from: 'manager', fromName: 'Manager', topic: `agent/${id}`, type: body.type, body: String(body.text || '').slice(0, 500), needsAck: true }, dir);
+          }
+          return send({ ok: true, sent: to.length });
+        }
+        if (p === '/bus/publish') {
+          const from = String(body.from || '');
+          const bound = bindPrincipal(auth, from);
+          if (bound.error) return send(bound, 403);
+          if (auth.via === 'cookie' && from && from !== 'user') return send({ error: 'forbidden principal' }, 403);
+          if (body.supersedes != null && !MESSAGE_ID.test(String(body.supersedes))) return send({ error: 'bad supersedes' }, 400);
+          const direct = typeof body.topic === 'string' && body.topic.startsWith('agent/') ? body.topic.slice(6) : null;
+          if (direct && ADDRESS.test(direct) && !bus.known(direct)) return send(unknownAddress(direct, bus.suggest(direct)), 400);
+          const env = hub.messaging.publish({
+            id: typeof body.id === 'string' ? body.id : null, from: bound.principal, fromName: body.fromName, topic: body.topic, type: body.type || 'MESSAGE',
+            body: body.body, needsAck: body.needsAck, ttlMs: body.ttlMs, replyTo: body.replyTo,
+            ...(body.supersedes != null ? { meta: { supersedes: body.supersedes } } : {}),
+          }, hub.registry.directory());
+          if (env.error) return send(env, 400);
+          caches.clear();
+          return send({ ...env, delivery: delivery.report(env) });
+        }
+        if (p === '/bus/register') {
+          const id = String(body.id || body.as || '');
+          const bound = bindPrincipal(auth, id);
+          if (bound.error) return send(bound, 403);
+          const result = hub.registry.register({ ...body, id: bound.principal });
+          if (result.error) return send(result, 400);
+          if (registeredAt) registeredAt.run(bound.principal, Date.now());
+          bus.proved(bound.principal, 'register');
+          caches.clear();
+          return send(result);
+        }
+        if (p === '/bus/ack' || p === '/bus/reply') {
+          const as = String(body.as || '');
+          const bound = bindPrincipal(auth, as);
+          if (bound.error) return send(bound, 403);
+          const box = bus.inboxFor(bound.principal, callerSession(body));
+          if (box.held) return send(heldAnswer(bound.principal, box.held), 409);
+          const inbox = routedMessaging(hub.messaging, box.addresses);
+          const reply = body.reply || body.body;
+          const sender = (typeof reply === 'string' && reply.trim()) || body.reaction ? delivery.senderOf(String(body.id || '')) : null;
+          if (sender && !bus.known(sender, { reply: true })) return send(unknownAddress(sender, bus.suggest(sender)), 400);
+          const result = inbox.ack(bound.principal, String(body.id || ''), { reply, fromName: body.fromName, reaction: body.reaction }, hub.registry.directory());
+          if (result.error) return send(result, 400);
+          caches.clear();
+          const offline = result.reply && sender ? bus.reach(sender) : null;
+          return send(offline && offline.reason === 'offline' ? { ...result, delivery: [{ to: sender, ...offline }] } : result);
+        }
+        if (p === '/api/runs/stop') {
+          const r = runner.stop(String(body.id || ''));
+          return r.error ? send(r, 404) : send(r);
+        }
+        if (p === '/api/decision') {
+          const file = typeof body.key === 'string' ? channelFileFor(body.key, channelRoots) : null;
+          const text = String(body.text || '').trim().slice(0, 4000);
+          if (!text) return send({ error: 'empty decision' }, 400);
+          if (!file) return send({ error: 'no such channel' }, 404);
+          const kind = body.kind === 'CHANGES REQUESTED' ? body.kind : 'DECISION';
+          appendNoFollow(file, decisionPost(text, { ref: typeof body.ref === 'string' ? body.ref : null, kind }));
+          hub.registry.appendEvent({ kind, actor: 'user', payload: { from: 'user', to: 'manager', type: kind, text: text.slice(0, 200), channel: body.key } });
+          caches.clear();
+          return send({ ok: true });
+        }
+        if (p === '/api/accept') {
+          if (typeof body.delivery !== 'string' || body.delivery.length > 100) return send({ error: 'invalid delivery' }, 400);
+          hub.registry.setFact('accepted', body.delivery, { at: Date.now() });
+          // The board's deliveries read acceptances from state/accepted.json (store.readAccepted), not from hub.db.
+          acceptDelivery(body.delivery);
+          hub.registry.appendEvent({ kind: 'ACCEPTED', actor: 'user', payload: { from: 'user', to: 'manager', type: 'ACCEPTED', ref: body.delivery, text: String(body.note || '').slice(0, 500) } });
+          caches.clear();
+          return send({ ok: true });
+        }
+        if (p === '/api/status') {
+          const want = statusRequest(body);
+          if (want.error) return send({ error: want.error }, 400);
+          const { target } = want;
+          if (target.kind === 'stream') {
+            const stream = hub.registry.fact('stream', target.id);
+            if (!stream) return send({ error: 'no such stream' }, 404);
+            if (stream.done) return send({ error: 'a finished stream does not move' }, 409);
+            const owner = hub.registry.facts('delivery').find((d) => (d.streams || []).some((s) => s.key === target.id));
+            const closed = owner && withOverride(owner, hub.registry.fact('status_override', `delivery:${owner.id}`), { kind: 'delivery', ...workMoved('delivery', owner) }).status === 'done';
+            if (closed) return send({ error: 'its delivery is closed, so its cards do not move' }, 409);
+            const key = overrideKey(target);
+            const prev = hub.registry.fact('status_override', key);
+            const holding = stepHolds(prev, stream);
+            const derived = STEP_IDS[stream.step];
+            if (holding ? prev.step === want.step : derived === want.step) {
+              if (prev && !holding) hub.registry.dropFact('status_override', key);
+              return send({ ok: true, unchanged: true, target, step: want.step, posted: [] });
+            }
+            const file = channelFileFor(target.id, channelRoots);
+            if (!file) return send({ error: 'this stream has no channel to note the move in' }, 409);
+            const at = Date.now();
+            const cleared = want.step === derived;
+            appendNoFollow(file, movePost(want, { at: new Date(at) }));
+            if (cleared) hub.registry.dropFact('status_override', key);
+            else hub.registry.setFact('status_override', key, { step: want.step, fromStep: stream.step, by: me() === NOBODY ? 'user' : me().name, at, seq: postsIn(file) });
+            hub.registry.appendEvent({ kind: 'STEP SET', actor: 'user', payload: { from: 'user', to: 'manager', type: 'STEP SET', ref: key, text: `moved to ${want.step}${cleared ? ' (its own step)' : ''}` } });
+            caches.clear();
+            feed.notify('hub');
+            return send({ ok: true, target, step: want.step, cleared, posted: [target.id] });
+          }
+          const row = hub.registry.fact(target.kind === 'delivery' ? 'delivery' : 'agent-row', target.id);
+          if (!row) return send({ error: `no such ${target.kind}` }, 404);
+          const prev = hub.registry.fact('status_override', overrideKey(target));
+          if (overrideHolds(prev, workMoved(target.kind, row)) && prev.status === want.status && (prev.reason || null) === want.reason && (prev.to || null) === want.to) {
+            return send({ ok: true, unchanged: true, target, status: want.status, posted: [] });
+          }
+          const at = Date.now();
+          const override = { status: want.status, reason: want.reason, to: want.to, by: me() === NOBODY ? 'user' : me().name, at };
+          const open = target.kind === 'delivery'
+            ? (row.streams || []).filter((s) => !s.done).map((s) => s.key)
+            : [row.streamKey].filter((k) => k && !(hub.registry.fact('stream', k) || {}).done);
+          const who = target.kind === 'agent' ? (row.persona && row.persona.name ? `${row.label} (${row.persona.name})` : row.label) : null;
+          const post = auditPost(override, { at: new Date(at), who });
+          const posted = [];
+          const seqs = {};
+          for (const key of open) {
+            const file = channelFileFor(key, channelRoots);
+            if (file) { appendNoFollow(file, post); posted.push(key); seqs[key] = postsIn(file); }
+          }
+          hub.registry.setFact('status_override', overrideKey(target), { ...override, seqs });
+          hub.registry.appendEvent({ kind: 'STATUS SET', actor: 'user', payload: { from: 'user', to: 'manager', type: 'STATUS SET', ref: overrideKey(target), text: overrideText(override) } });
+          caches.clear();
+          feed.notify('hub');
+          return send({ ok: true, target, status: want.status, posted });
+        }
+        if (p === '/api/chat/post') {
+          const ch = String(body.ch || '');
+          const text = String(body.text || '').trim().slice(0, 4000);
+          const refuse = (error, code = 400) => { console.error(`chat post refused (${ch.split(':')[0] || 'none'}): ${error}`); return send({ error }, code); };
+          if (!text) return refuse('empty message');
+          if (auth.via === 'cookie' && body.from && body.from !== 'user') return send({ error: 'forbidden principal' }, 403);
+          if (ch.startsWith('task:')) {
+            const file = channelFileFor(ch.slice(5), channelRoots);
+            if (!file) return refuse('no such channel', 404);
+            appendNoFollow(file, decisionPost(text, { kind: 'MESSAGE' }));
+            caches.clear();
+            return send({ ok: true });
+          }
+          if (ch.startsWith('project:') && postToProject(ch.slice(8), 'USER', text)) return send({ ok: true });
+          if (ch.startsWith('dm:')) {
+            const recipient = ch.slice(3);
+            const part = channelParticipant(recipient);
+            if (part) {
+              const file = channelFileFor(part.key, channelRoots);
+              if (!file) return refuse('no such person');
+              appendNoFollow(file, participantPost(part.role, text));
+              hub.registry.appendEvent({ kind: 'MESSAGE', actor: 'user', payload: { from: 'user', to: recipient, type: 'MESSAGE', text: text.slice(0, 200), channel: part.key } });
+              caches.clear();
+              return send({ ok: true, delivered: true, via: 'channel', channel: part.key });
+            }
+            if (!ADDRESS.test(recipient)) return refuse(recipient === 'hub' ? 'the hub itself takes no direct messages' : 'this person has no inbox the hub can reach');
+            const file = typeof body.key === 'string' ? channelFileFor(body.key, channelRoots) : null;
+            const channel = file ? body.key.split('/').pop() : null;
+            const role = typeof body.role === 'string' && /^[A-Z][A-Z0-9-]{0,39}$/.test(body.role) ? body.role : null;
+            const name = body.wake && typeof body.wake === 'object' && typeof body.wake.name === 'string' ? body.wake.name.slice(0, 80) : null;
+            const env = hub.messaging.publish({
+              from: 'user', fromName: 'You', topic: recipient === 'manager' ? 'manager' : `agent/${recipient}`,
+              type: 'MESSAGE', body: text, needsAck: true,
+              meta: { voice: hasChatInbox(recipient) ? voiceFor(recipient, role) : null, channel },
+            }, hub.registry.directory());
+            if (env.error || !env.to.length) return refuse(env.error || 'no such person');
+            const seen = hub.registry.presence(recipient);
+            const running = seen && Date.now() - seen.last_seen < STOPPED_MS && seen.last_event !== 'stop';
+            const wake = running ? null : requestWake(hub, recipient, { name });
+            caches.clear();
+            return send({ ok: true, messageId: env.id, queued: true, wake: wake ? wake.parent : null });
+          }
+          return refuse('no such channel');
+        }
+        if (p === '/api/settings') {
+          const next = writeSettings(body);
+          hub.registry.setFact('settings', 'hub', next);
+          return send({ ...next, keepAwakeStatus: keepAwakeStatus(), me: me() });
+        }
+        if (p === '/api/legacy/request') {
+          const id = `r-${Date.now().toString(36)}`;
+          const reqBody = {
+            id, from: [String(body.from || 'user')], kind: String(body.kind ?? 'platform'),
+            title: String(body.title ?? ''), files: (body.files ?? '').split(',').filter(Boolean),
+            status: 'queued', at: Date.now(),
+          };
+          hub.registry.setFact('request', id, reqBody);
+          hub.registry.appendEvent({ kind: 'REQUEST', actor: reqBody.from[0], payload: { ...reqBody, type: 'REQUEST', text: `${reqBody.kind}: ${reqBody.title}` } });
+          return send(reqBody);
+        }
+        if (p === '/api/legacy/post') {
+          const event = { from: body.from || 'user', to: body.to ?? '*', type: body.type ?? 'NOTE', text: body.text ?? '', at: Date.now() };
+          hub.registry.appendEvent({ kind: event.type, actor: event.from, payload: event });
+          return send(event);
+        }
+        if (p === '/api/legacy/wait') {
+          const forId = String(body.for || '');
+          const hit = hub.messaging.claim(forId, { via: 'wait', limit: 1 });
+          if (hit.length) {
+            hub.messaging.markDelivered(forId, hit.map((m) => m.id), { via: 'wait' });
+            return send({ message: hit[0] });
+          }
+          const ev = hub.registry.eventsSince(Number(body.since) || 0, 20).find((e) => e.to === forId || e.to === '*');
+          return send(ev ? { event: ev } : {});
+        }
+        return send({ error: 'not found' }, 404);
+      });
+    });
+  };
+
+  const server = http.createServer((req, res) => {
+    const started = Date.now();
+    try {
+      if (!LOCAL_HOST.test(req.headers.host || '')) return sendJson(res, { error: 'unknown host' }, 421);
+      if (req.method !== 'GET' && req.method !== 'POST') return sendJson(res, { error: 'method not allowed' }, 405);
+      if (req.method === 'POST' && !trustedWrite(req)) {
+        console.error(`write refused: ${req.url.split('?')[0]} origin=${req.headers.origin || '-'} site=${req.headers['sec-fetch-site'] || '-'} type=${req.headers['content-type'] || '-'}`);
+        return sendJson(res, { error: 'forbidden' }, 403);
+      }
+      let url; let p;
+      try { url = new URL(req.url, 'http://127.0.0.1'); p = decodeURIComponent(url.pathname); } catch { return sendJson(res, { error: 'bad path' }, 400); }
+      if (p.includes('\0')) return sendJson(res, { error: 'bad path' }, 400);
+      const auth = authenticate(req, hub.token, { asHint: url.searchParams.get('as') });
+      const publicPath = p === '/' || p === '/index.html' || p.startsWith('/ui/') || p.startsWith('/shared/');
+      if (!publicPath && !auth) {
+        if (req.method === 'POST') console.error(`write refused: ${p} not signed in (cookie ${req.headers.cookie && req.headers.cookie.includes('hub_auth=') ? 'stale' : 'missing'})`);
+        return sendJson(res, { error: 'unauthorized' }, 401);
+      }
+      const stale = health().staleSeconds;
+      if (Number.isFinite(stale) && stale > 35) res.setHeader('x-pulse-stale', String(Math.round(stale)));
+      return routes(req, res, p, url, auth, started);
+    } catch (e) {
+      console.error(`request failed: ${req.method} ${req.url}: ${e && e.stack ? e.stack : e}`);
+      if (!res.headersSent) sendJson(res, { error: 'server error' }, 500);
+      else res.end();
+      return undefined;
+    }
+  });
+  server.on('close', () => {
+    feed.close();
+    for (const t of timers) clearInterval(t);
+    manager.stop();
+    releaseLease();
+  });
+  server.listen(port, listenHost);
+  return { server, manager, graphs, runner, feed };
+}