@agentpulselabs/cli-plugin-pulse 1.0.0 → 1.1.2

package/src/hub/lib/closure.mjs

@@ -0,0 +1,92 @@
+// Pulse 1.1.1 (F3): the terminal headers of agents-hub.mdc and delivery-discipline.mdc, and what each one ends. Pure
+// and dependency-free: the plugin (src/hub/lib/closure.mjs) and the cloud (bll/projections/closure.js) hold this file
+// byte for byte, and both test it against the same test/fixtures/closure-cases.json.
+
+/** What keeps a FINAL header from being a pass (channels.mjs at 6b2fb0b). */
+const FINAL_HOLD = /\bFAIL(ED|S)?\b|\bBLOCKED\b|\bPENDING\b|\bWAITING\b|\bSTARTING\b|\bNOT (A )?(RELEASE )?SIGN-OFF\b/;
+const isFinal = (head) => /^FINAL\b/.test(head);
+const finalFails = (head) => isFinal(head) && /\bFAIL(ED|S)?\b/.test(head);
+const finalPasses = (head) => isFinal(head) && !FINAL_HOLD.test(head) && (!/^FINAL REVIEW\b/.test(head) || /\b(PASS|APPROVED)\b/.test(head));
+/** Matched as words at the start of the type, with or without a dash after: `STOPPED`, `STOPPED: why`, `STOPPED — why`. */
+const TERMINAL = [
+  [/^RELEASE ABORTED\b/, 'stopped'],
+  [/^RELEASED\b/, 'passed'],
+  [/^STOPPED\b/, 'stopped'],
+  [/^HANDED OVER\b/, 'handed-over'],
+  [/^DONE\b/, 'done'],
+];
+const RELEASE = /^(RELEASED|RELEASE ABORTED)\b/;
+const REOPENS = /^(READY|KICKOFF|RESUMED|PLAN)\b/;
+/** Posts that do not move the work (channels.mjs CHATTER at 6b2fb0b). */
+const CHATTER = /^(WAITING|STATUS|JOINED|POST|NOTE|ACK(?! COMMITTED)|STOPPING|STOOD DOWN|HEARTBEAT|PROGRESS)/;
+const TEXT = {
+  passed: 'Final review passed', failed: 'Final review failed', done: 'Closed: marked done', stopped: 'Closed: stopped', 'handed-over': 'Closed: handed over',
+};
+
+const upper = (s) => String(s || '').toUpperCase().trim();
+const isUser = (p) => upper(p.role) === 'USER';
+const isReviewer = (p) => upper(p.role).includes('REVIEWER');
+
+/** What a header says about its author's own work: passed, failed, done, stopped or handed-over; null when it ends nothing. */
+export function roleOutcome(p) {
+  if (!p || isUser(p)) return null;
+  const head = upper(p.head || p.type);
+  if (isReviewer(p) && isFinal(head)) return finalFails(head) ? 'failed' : finalPasses(head) ? 'passed' : null;
+  const hit = TERMINAL.find(([re]) => re.test(upper(p.type)));
+  return hit ? hit[1] : null;
+}
+
+/**
+ * The outcome one header closes the whole stream with, or null: a reviewer's final pass, a release or its abort, or
+ * any terminal header of the stream's ARCHITECT, who owns it. A FINAL: FAIL ends only the reviewer's own turn.
+ */
+export function streamCloser(p) {
+  const outcome = roleOutcome(p);
+  if (!outcome || outcome === 'failed') return null;
+  if (isReviewer(p) && outcome === 'passed') return outcome;
+  if (RELEASE.test(upper(p.type))) return outcome;
+  return upper(p.role) === 'ARCHITECT' ? outcome : null;
+}
+
+/**
+ * Pulse 1.1.2 (E2, E3): a header that ends its author's turn, so a channel whose newest post is one is not waiting on
+ * anyone: FINAL: PASS or FAIL, DONE, STOPPED, HANDED OVER, RELEASED, RELEASE ABORTED, or APPROVED from a reviewer.
+ */
+export function isTerminal(p) {
+  if (!p || isUser(p)) return false;
+  return Boolean(roleOutcome(p)) || (isReviewer(p) && /^APPROVED\b/.test(upper(p.type)));
+}
+
+/** A READY, KICKOFF, RESUMED or PLAN from an agent reopens a closed stream. */
+export const reopens = (p) => !!p && !isUser(p) && REOPENS.test(upper(p.type));
+
+const moves = (p) => !isUser(p) && !CHATTER.test(upper(p.type));
+
+/**
+ * With no single closer standing: the stream is closed when every role that posted moving headers (USER left out)
+ * has a terminal one as its latest, none of them failed, and whoever holds the ball (`ball`, as analyseStream names
+ * it: CODER, REVIEWER, ARCHITECT, AUDITOR or YOU) is one of those roles. A coder's DONE hands the ball to an architect
+ * who has not posted, so it leaves the stream open. The newest terminal header names the outcome. Posts oldest first.
+ */
+export function everyRoleClosed(posts, ball = null) {
+  const latest = new Map();
+  for (const p of posts || []) if (moves(p)) latest.set(upper(p.role), p);
+  if (!latest.size || ball === 'YOU') return null;
+  if (ball && ![...latest.keys()].some((role) => role.includes(ball))) return null;
+  const ends = [...latest.values()].map((p) => ({ p, outcome: roleOutcome(p) }));
+  if (!ends.every((e) => e.outcome && e.outcome !== 'failed')) return null;
+  return ends.reduce((a, b) => ((b.p.at || 0) >= (a.p.at || 0) ? b : a)).outcome;
+}
+
+/** The words a closed stream's card shows. */
+export const closedText = (outcome) => TEXT[outcome] || TEXT.passed;
+
+/** A delivery whose streams are all closed: "Final review passed" when every one passed, else what each ended as. */
+export function closedReason(outcomes) {
+  const list = outcomes.map((o) => o || 'passed');
+  if (list.every((o) => o === 'passed')) return TEXT.passed;
+  const counts = new Map();
+  for (const o of list) counts.set(o, (counts.get(o) || 0) + 1);
+  const words = { passed: 'passed', done: 'marked done', stopped: 'stopped', 'handed-over': 'handed over' };
+  return `Closed: ${[...counts].map(([o, n]) => `${n} ${words[o] || o}`).join(', ')}`;
+}

package/src/hub/lib/collect-worker.mjs

@@ -0,0 +1,20 @@
+// agents-hub lib/collect-worker.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// Runs collect() off the server's event loop, then persists discoveries and returns a pure projection.
+import path from 'node:path';
+import { hubHome, runnerDb } from '../home.mjs';
+import { parentPort } from 'node:worker_threads';
+import { collect } from './collect.mjs';
+import { openHub } from '../core/hub.mjs';
+import { discoveryRunner } from '../workers/collector.mjs';
+
+const HUB_ROOT = hubHome();
+const hub = openHub(path.join(HUB_ROOT, 'state'), runnerDb());
+const run = discoveryRunner({ hub, collect });
+
+parentPort.on('message', ({ id, hours, managerView, aliases, discoveryEpoch }) => {
+  try {
+    parentPort.postMessage({ id, body: run(hours, managerView, aliases, { discoveryEpoch }) });
+  } catch (e) {
+    parentPort.postMessage({ id, error: String((e && e.stack) || e) });
+  }
+});

package/src/hub/lib/collect.mjs

@@ -0,0 +1,342 @@
+// agents-hub lib/collect.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// Builds everything the hub shows from what sessions leave on disk: Cursor transcripts (who exists, who started whom,
+// what each agent was asked), task channels (what happened, who has the ball) and the hub's own requests and events.
+// Tokens are an estimate (transcript bytes / 4): transcripts hold no usage, tool output or system prompts.
+import fs from 'node:fs';
+import path from 'node:path';
+import { managerChats } from '../core/ids.mjs';
+import { channelFiles, firstHeading, holds, parsePosts } from './channels.mjs';
+import { hasChatInbox, liveOf } from './chat.mjs';
+import { chatTitles } from './titles.mjs';
+import { buildAgents, buildDeliveries, streamView } from './deliveries.mjs';
+import { gitInfo, plannedCheckout, taskCheckout } from './git.mjs';
+import { personaFor, savePersonas } from './personas.mjs';
+import { HUB, readAccepted, readRequests } from './store.mjs';
+import { channelsOwned, pruneOwnCache, scanSessions, scanTranscripts, sessionTail, topSession } from './transcripts.mjs';
+
+const WORK = path.resolve(HUB, '..');
+const CHANNEL_ROOTS = ['AgentPulseApps', 'Google_Cloud'].map((d) => path.join(WORK, d));
+const ACTIVE_MS = 10 * 60e3;
+const IDLE_MS = 60 * 60e3;
+const ORPHAN_LOOKBACK_MS = 48 * 3600e3;
+/** A subagent file this small is the launch stub only; its real conversation was not saved, so its tokens are unknown. */
+const STUB_BYTES = 8 * 1024;
+const MANAGER = 'manager';
+/** Ids of the requests collect derives from channel posts. Other request facts (hub.mjs request, imports) are not its. */
+export const DERIVED_REQUEST_PREFIX = 'd-';
+const REQUEST_HINT = /\bPROMOTE\b|platform gap|needs? (?:a )?platform change|common script/i;
+
+/** The hub's Cursor hook fires on every tool call, so a chat it heard from this recently is running and gets messages at its next step. */
+const LIVE_MS = 3 * 60e3;
+
+function withLive(row, now) {
+  const chatInbox = hasChatInbox(row.id);
+  const live = chatInbox ? liveOf(row.id) : null;
+  row.reach = { ...row.reach, chatInbox, live };
+  if (!live || row.reach.state === 'finished' || live.at < row.reach.lastAt - LIVE_MS) return;
+  if (live.event === 'stop') row.reach.state = 'turn-ended';
+  else if (now - live.at < LIVE_MS) row.reach.state = 'connected';
+}
+
+const statusOf = (lastAt, now) => (now - lastAt < ACTIVE_MS ? 'active' : now - lastAt < IDLE_MS ? 'idle' : 'done');
+/**
+ * What header totals are counted from, so a window can filter one canonical pass (projections/graph.mjs). One entry per
+ * person, [kind 's' | 'a' | 'o', seenAt, lastAt, tokensEst], where seenAt is the later of lastAt and `seenAt`: a role
+ * that posted inside a window, holds the ball of a stream touched in it, or runs under the hub is in it even when its
+ * transcript is older. Message events collapse to [at, count].
+ */
+export function totalsBasis(people, events, seenAt = new Map()) {
+  const counts = new Map();
+  for (const e of events) counts.set(e.at, (counts.get(e.at) || 0) + 1);
+  const kind = (n) => (n.kind === 'session' ? 's' : n.kind === 'agent' ? 'a' : 'o');
+  return {
+    people: people.map((n) => [kind(n), Math.max(n.lastAt || 0, seenAt.get(n.id) || 0), n.lastAt || 0, n.tokensEst || 0]),
+    messages: [...counts].sort((a, b) => a[0] - b[0]),
+  };
+}
+
+const titleCase = (s) => s.toLowerCase().replace(/(^|\s)\w/g, (c) => c.toUpperCase());
+
+function recipients(role, roles) {
+  const others = roles.filter((r) => r !== role);
+  if (role.includes('CODER')) return others.filter((r) => r.includes('REVIEWER') || r.includes('AUDITOR'));
+  if (role.includes('REVIEWER') || role.includes('AUDITOR')) return others.filter((r) => r.includes('CODER'));
+  return others.filter((r) => !r.includes('AUDITOR'));
+}
+
+/**
+ * Each stream belongs to one session: the parent of its agents, else the most recent session (up to 48 h back) whose
+ * briefs or writes name it. Sessions found that way join the node list, since they are the streams' architects.
+ */
+function assignOwners(nodes, channels, index, now) {
+  const owner = new Map();
+  for (const c of channels) {
+    const parented = [...nodes.values()].find((n) => n.channelKey === c.key && n.parent && nodes.get(n.parent) && nodes.get(n.parent).kind === 'session');
+    if (parented) owner.set(c.key, parented.parent);
+  }
+  const missing = new Set(channels.filter((c) => !owner.has(c.key)).map((c) => c.key));
+  if (missing.size) {
+    for (const s of scanSessions(now - ORPHAN_LOOKBACK_MS, index).sort((a, b) => b.lastAt - a.lastAt)) {
+      if (!missing.size) break;
+      const top = topSession(s.id, index) || s;
+      for (const k of channelsOwned(s.file, index)) {
+        if (!missing.has(k)) continue;
+        missing.delete(k);
+        owner.set(k, top.id);
+        if (!nodes.has(top.id)) nodes.set(top.id, top);
+      }
+    }
+  }
+  pruneOwnCache(now - ORPHAN_LOOKBACK_MS);
+  for (const n of nodes.values()) if (n.kind === 'agent' && !n.parent && n.channelKey && owner.has(n.channelKey) && owner.get(n.channelKey) !== n.id) n.parent = owner.get(n.channelKey);
+  return owner;
+}
+
+/**
+ * Whoever holds a stream's ball must be on the map even if it has not posted inside the time window (a coder sitting
+ * on a failed review is exactly what you need to see): add it from its last post in the channel.
+ */
+function addBallHolders(nodes, streams, owner, now) {
+  for (const s of streams.values()) {
+    if (s.done || !s.ball || s.ball === 'YOU' || s.ball === 'ARCHITECT') continue;
+    if ([...nodes.values()].some((n) => n.channelKey === s.key && n.role && holds(n.role, s.ball))) continue;
+    const [role, post] = Object.entries(s.lastByRole).filter(([r]) => holds(r, s.ball)).sort((a, b) => b[1].at - a[1].at)[0] || [];
+    if (!role) continue;
+    const id = `${s.key}:${role}`;
+    nodes.set(id, { id, kind: 'agent', role, task: s.channel, channel: s.channel, channelKey: s.key, repo: s.repo, label: titleCase(role),
+      title: `${role} on ${s.channel} (seen only in its channel)`, parent: owner.get(s.key) || null, startedAt: post.at, lastAt: post.at, bytes: 0, tokensEst: null, status: statusOf(post.at, now), synthetic: true });
+  }
+}
+
+/**
+ * When each stream's ball holder was last on the map. A window shows the holder whenever the stream's channel changed
+ * inside it (addBallHolders), so in the canonical pass the holder counts as seen at the channel's last change.
+ */
+function ballHeldAt(nodes, streams, channels) {
+  const changed = new Map(channels.map((c) => [c.key, c.mtime]));
+  const held = new Map();
+  for (const s of streams.values()) {
+    if (s.done || !s.ball || s.ball === 'YOU' || s.ball === 'ARCHITECT') continue;
+    if (!Object.keys(s.lastByRole).some((r) => holds(r, s.ball))) continue;
+    let holder = null;
+    for (const n of nodes.values()) if (n.channelKey === s.key && n.role && holds(n.role, s.ball) && (!holder || n.lastAt > holder.lastAt)) holder = n;
+    if (holder) held.set(holder.id, Math.max(held.get(holder.id) || 0, changed.get(s.key) || 0));
+  }
+  return held;
+}
+
+/** Task titles from the briefs each owner session gave its subagents: for agents without their own transcript, and per stream. */
+function applyBriefs(nodes, channels, owner, index) {
+  const byKey = new Map();
+  for (const sid of new Set(owner.values())) {
+    const s = nodes.get(sid);
+    if (!s || !s.file) continue;
+    for (const [k, roles] of channelsOwned(s.file, index).briefs) byKey.set(k, roles);
+  }
+  const titles = new Map();
+  for (const c of channels) {
+    const roles = byKey.get(c.key);
+    c.title = streamTitle(c) || (roles && [...roles.values()].map((b) => b.title).find(Boolean)) || null;
+    titles.set(c.key, c.title);
+  }
+  for (const n of nodes.values()) {
+    if (n.kind !== 'agent' || n.taskTitle || !n.channelKey) continue;
+    const roles = byKey.get(n.channelKey);
+    const b = roles && (roles.get(n.role) || [...roles.values()].find((x) => n.role && x.role && (x.role.endsWith(n.role) || n.role.endsWith(x.role))));
+    n.taskTitle = (b && b.title) || titles.get(n.channelKey) || null;
+    if (b && (!n.task || n.synthetic)) n.task = b.code;
+  }
+}
+
+/** A stream's title: the heading of brief.md beside its channel, else of the spec its KICKOFF names. */
+function streamTitle(c) {
+  const dir = path.dirname(c.file);
+  const brief = firstHeading(path.join(dir, 'brief.md'));
+  if (brief) return brief;
+  const kickoff = c.posts.find((p) => /^KICKOFF/.test(p.type.toUpperCase()));
+  const spec = kickoff && kickoff.text.match(/(docs\/[A-Za-z0-9._/-]+\.md)/);
+  if (!spec || spec[1].split('/').includes('..')) return null;
+  const repoDir = path.resolve(dir, '..', '..');
+  return firstHeading(path.join(repoDir, spec[1]));
+}
+
+const postCache = new Map();
+/** A channel's posts, re-parsed only when the file changed. */
+function postsOf(c) {
+  let size = 0;
+  try { size = fs.statSync(c.file).size; } catch { return []; }
+  const hit = postCache.get(c.file);
+  if (hit && hit.mtime === c.mtime && hit.size === size) return hit.posts;
+  let posts = [];
+  try { posts = parsePosts(fs.readFileSync(c.file, 'utf8'), c.mtime); } catch { /* unreadable */ }
+  if (postCache.size > 2000) postCache.clear();
+  postCache.set(c.file, { mtime: c.mtime, size, posts });
+  return posts;
+}
+
+/** The whole picture for the last `hours`. */
+/** Hub-owned agents (runs): their sessions may have a Cursor transcript (relabel it) or none (Claude, other CLIs). */
+function adoptRuns(nodes, runs, since) {
+  for (const r of runs) {
+    if (r.state === 'stopped' && (r.lastAt || r.createdAt) < since) continue;
+    const prev = nodes.get(r.id);
+    const channel = r.stream ? r.stream.split('/').pop() : null;
+    nodes.set(r.id, {
+      ...(prev || { bytes: 0, tokensEst: null }),
+      id: r.id, kind: 'agent', role: r.role, parent: r.parent || MANAGER, channelKey: r.stream || null, channel, task: channel,
+      repo: path.basename(r.workspace), label: titleCase(r.role), title: r.name || `${r.role} (${r.driver}, hub-owned)`,
+      startedAt: (prev && prev.startedAt) || r.createdAt, lastAt: Math.max((prev && prev.lastAt) || 0, r.lastAt || r.createdAt),
+      hubRun: { driver: r.driver, state: r.state, turns: r.turns || 0, costUsd: r.costUsd || 0, lastError: r.lastError || null },
+    });
+  }
+}
+
+export function collect({ hours = 6, runs = [], aliases = [] } = {}) {
+  const now = Date.now();
+  const since = now - hours * 3600e3;
+  const channels = channelFiles(CHANNEL_ROOTS, since);
+  const index = new Map();
+  for (const c of channels) {
+    c.posts = postsOf(c);
+    if (!index.has(c.task)) index.set(c.task, []);
+    index.get(c.task).push(c.key);
+  }
+  const nodes = scanTranscripts(since, index);
+  adoptRuns(nodes, runs, since);
+  // The headless Hub Manager has a Cursor transcript too, but it is the single central manager node, not a user
+  // delivery. Any subagents it starts hang from that manager node.
+  let ownChats = new Set();
+  try { ownChats = managerChats(JSON.parse(fs.readFileSync(path.join(HUB, 'state', 'manager.json'), 'utf8'))); } catch { /* manager not configured */ }
+  for (const chat of ownChats) nodes.delete(chat);
+  for (const n of nodes.values()) if (ownChats.has(n.parent)) n.parent = MANAGER;
+  const owner = assignOwners(nodes, channels, index, now);
+  /** A stream run by a subagent belongs to the session at the top of its chain. */
+  const rootOf = (id) => { let n = nodes.get(id); for (let i = 0; n && n.kind === 'agent' && n.parent && i < 8; i++) n = nodes.get(n.parent); return n && n.kind === 'session' ? n.id : null; };
+  for (const [k, id] of owner) { const n = nodes.get(id); if (n && n.kind === 'agent') { const root = rootOf(id); if (root) owner.set(k, root); else owner.delete(k); } }
+  for (const n of nodes.values()) {
+    n.status = statusOf(n.lastAt, now);
+    n.tokensEst = n.parent && n.bytes < STUB_BYTES ? null : Math.round(n.bytes / 4);
+  }
+  for (const c of channels) {
+    c.checkout = gitInfo(path.resolve(path.dirname(c.file), '..', '..'));
+    const kickoff = c.posts.find((p) => /^KICKOFF/.test(p.type.toUpperCase()));
+    c.planned = kickoff ? plannedCheckout(kickoff.text) : null;
+    c.git = taskCheckout(c.checkout, c.planned);
+  }
+  const streams = new Map(channels.map((c) => [c.key, streamView(c, { aliases })]));
+  addBallHolders(nodes, streams, owner, now);
+  const seenAt = ballHeldAt(nodes, streams, channels);
+  for (const n of nodes.values()) if (n.hubRun && n.hubRun.state !== 'stopped') seenAt.set(n.id, now);
+
+  const events = [];
+  const linkCount = new Map();
+  const bump = (a, b, kind) => { const k = `${a}|${b}|${kind}`; linkCount.set(k, (linkCount.get(k) || 0) + 1); };
+  const byKeyRole = new Map();
+  for (const n of nodes.values()) if (n.channelKey && n.role) {
+    const k = `${n.channelKey}|${n.role}`;
+    const prev = byKeyRole.get(k);
+    if (!prev || prev.lastAt < n.lastAt) byKeyRole.set(k, n);
+  }
+  const derived = [];
+  const derivedIds = new Map();
+  for (const c of channels) {
+    const posts = c.posts.filter((p) => p.at >= since);
+    if (!posts.length) continue;
+    const roles = [...new Set(posts.map((p) => p.role))];
+    const architect = owner.get(c.key) || null;
+    const nodeFor = (role) => {
+      if (role === 'USER') return 'user';
+      const hit = byKeyRole.get(`${c.key}|${role}`);
+      if (hit) return hit.id;
+      if (role === 'ARCHITECT' && architect) return architect;
+      const id = `${c.key}:${role}`;
+      if (!nodes.has(id)) {
+        const mine = posts.filter((p) => p.role === role);
+        const last = mine[mine.length - 1].at;
+        nodes.set(id, { id, kind: 'agent', role, task: c.task, channel: c.task, channelKey: c.key, repo: c.repo, label: titleCase(role),
+          title: `${role} on ${c.task} (seen only in its channel)`, parent: architect, startedAt: mine[0].at, lastAt: last, bytes: 0, tokensEst: null, status: statusOf(last, now), synthetic: true });
+      }
+      return id;
+    };
+    for (const p of posts) {
+      const from = nodeFor(p.role);
+      seenAt.set(from, Math.max(seenAt.get(from) || 0, p.at));
+      for (const r of recipients(p.role, roles)) {
+        const to = nodeFor(r);
+        events.push({ at: p.at, from, to, type: p.type, text: p.text.slice(0, 300), channel: c.task });
+        bump(from, to, 'msg');
+      }
+      if (!REQUEST_HINT.test(p.head)) continue;
+      // Posts share a second often enough; each is its own request.
+      const base = `${DERIVED_REQUEST_PREFIX}${c.key}-${p.at}`;
+      const seq = derivedIds.get(base) || 0;
+      derivedIds.set(base, seq + 1);
+      derived.push({ id: seq ? `${base}-${seq}` : base, title: p.text.replace(/^[^—]*— ?/, '').slice(0, 120), kind: 'platform', from: [from], status: 'unfiled', at: p.at, channel: c.task });
+    }
+  }
+
+  const requests = [...readRequests().filter((r) => r.at >= since), ...derived];
+  for (const r of requests) for (const f of r.from) if (nodes.has(f)) bump(f, MANAGER, 'request');
+  nodes.set(MANAGER, { id: MANAGER, kind: 'manager', label: 'Manager', title: 'Owns shared changes: platform, common scripts, rules', status: 'active', startedAt: since, lastAt: now, tokensEst: null });
+
+  const links = [];
+  for (const n of nodes.values()) if (n.parent && nodes.has(n.parent)) links.push({ source: n.parent, target: n.id, kind: 'spawn', count: 1 });
+  for (const [k, count] of linkCount) {
+    const [source, target, kind] = k.split('|');
+    if (nodes.has(source) && nodes.has(target) && source !== target) links.push({ source, target, kind, count });
+  }
+  const sent = new Map();
+  const got = new Map();
+  for (const e of events) { sent.set(e.from, (sent.get(e.from) || 0) + 1); got.set(e.to, (got.get(e.to) || 0) + 1); }
+  events.sort((a, b) => a.at - b.at);
+
+  applyBriefs(nodes, channels, owner, index);
+  for (const c of channels) { const v = streams.get(c.key); if (v) v.title = c.title || null; }
+  for (const n of nodes.values()) {
+    if (n.kind !== 'agent' && !(n.kind === 'session' && !n.parent)) continue;
+    const p = personaFor(n.id, { role: n.kind === 'agent' ? n.role : 'ARCHITECT', channel: n.channelKey || null, now: Math.min(now, n.startedAt || now) });
+    n.persona = { name: p.name, first: p.first, username: p.username, seed: p.seed, personality: p.personality || null };
+  }
+  savePersonas();
+  const sessions = [...nodes.values()].filter((n) => n.kind === 'session' && !n.parent && n.file);
+  const kids = new Map();
+  for (const n of nodes.values()) if (n.parent && n.kind === 'agent') { if (!kids.has(n.parent)) kids.set(n.parent, []); kids.get(n.parent).push(n); }
+  const tails = new Map(sessions.map((s) => [s.id, sessionTail(s.file)]));
+  const deliveries = buildDeliveries({ sessions, kids, streams, owner, tails, acks: readAccepted(), now });
+  const names = chatTitles(deliveries.map((d) => d.id));
+  for (const d of deliveries) {
+    d.name = names.get(d.id) || null;
+    const session = nodes.get(d.id);
+    if (session) Object.assign(session, {
+      role: 'ARCHITECT', nodeType: 'delivery', chatTitle: d.name || d.title, label: d.name || d.title, promptTitle: d.title,
+      deliveryId: d.id, project: d.projects.join(', '),
+    });
+  }
+  const nodeList = [...nodes.values()];
+  const agentRows = buildAgents({ nodes: nodeList, streams, owner, deliveries, tails, now });
+  for (const row of agentRows) withLive(row, now);
+  const RUN_STATUS = { working: 'working', queued: 'working', idle: 'waiting', error: 'stuck', stopped: 'done' };
+  for (const row of agentRows) {
+    const n = nodes.get(row.id);
+    if (!n || !n.hubRun) continue;
+    row.hubRun = n.hubRun;
+    row.status = RUN_STATUS[n.hubRun.state] || row.status;
+    row.reach = { ...row.reach, state: n.hubRun.state === 'stopped' ? 'finished' : 'connected', chatInbox: n.hubRun.state !== 'stopped', hubRun: n.hubRun.driver };
+  }
+
+  const list = nodeList.map(({ file, bytes, ...n }) => ({ ...n, msgsOut: sent.get(n.id) || 0, msgsIn: got.get(n.id) || 0 }));
+  const people = list.filter((n) => n.kind !== 'manager');
+  return {
+    generatedAt: now, hours, deliveries, agents: agentRows,
+    totals: {
+      sessions: people.filter((n) => n.kind === 'session').length,
+      agents: people.filter((n) => n.kind === 'agent').length,
+      active: people.filter((n) => n.status === 'active').length,
+      messages: events.length,
+      tokensEst: people.reduce((s, n) => s + (n.tokensEst || 0), 0),
+      requests: requests.length,
+    },
+    totalsBasis: totalsBasis(people, events, seenAt),
+    nodes: list, links, events: events.slice(-400), requests: requests.sort((a, b) => b.at - a.at),
+  };
+}