@agentpulselabs/cli-plugin-pulse 1.0.0 → 1.1.3

package/src/hub/lib/transcript-feed.mjs

@@ -0,0 +1,72 @@
+// agents-hub lib/transcript-feed.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Notices Cursor transcript writes within about a second without fs.watch: a recursive watch over ~/.cursor/projects
+ * (hundreds of folders) runs out of file handles and then dies silently. Instead, stat the recently active session
+ * files every second, and rescan every session every 30 s so a resumed old session or a new project is picked up.
+ */
+const FAST_MS = 1000;
+const FULL_MS = 30e3;
+const ACTIVE_MS = 6 * 3600e3;
+
+const safe = (fn, fallback) => { try { return fn(); } catch { return fallback; } };
+const dirs = (dir) => safe(() => fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name), []);
+const jsonl = (dir) => safe(() => fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl')).map((f) => path.join(dir, f)), []);
+const sig = (file) => safe(() => { const s = fs.statSync(file); return { m: s.mtimeMs, z: s.size }; }, null);
+
+function sessionFiles(sessionDir) {
+  return [...jsonl(sessionDir), ...jsonl(path.join(sessionDir, 'subagents'))];
+}
+
+export function watchTranscripts(projectsDir, onChange) {
+  const seen = new Map();
+  const activeSessions = new Set();
+  const activeRoots = new Set();
+
+  const check = (file, now, notify) => {
+    const s = sig(file);
+    if (!s) return false;
+    const was = seen.get(file);
+    seen.set(file, s);
+    if (notify && (!was || was.m !== s.m || was.z !== s.z)) onChange(file);
+    return now - s.m < ACTIVE_MS;
+  };
+
+  const full = (notify) => {
+    const now = Date.now();
+    activeSessions.clear();
+    activeRoots.clear();
+    for (const project of dirs(projectsDir)) {
+      const root = path.join(projectsDir, project, 'agent-transcripts');
+      const sessions = dirs(root);
+      if (!sessions.length) continue;
+      const rootRecent = now - (sig(root)?.m || 0) < ACTIVE_MS;
+      let any = false;
+      for (const id of sessions) {
+        const dir = path.join(root, id);
+        let live = false;
+        for (const f of sessionFiles(dir)) live = check(f, now, notify) || live;
+        if (live) { activeSessions.add(dir); any = true; }
+      }
+      if (any || rootRecent) activeRoots.add(root);
+    }
+  };
+
+  const fast = () => {
+    const now = Date.now();
+    for (const root of activeRoots) {
+      for (const id of dirs(root)) {
+        const dir = path.join(root, id);
+        if (!activeSessions.has(dir) && sessionFiles(dir).some((f) => !seen.has(f))) activeSessions.add(dir);
+      }
+    }
+    for (const dir of activeSessions) for (const f of sessionFiles(dir)) check(f, now, true);
+  };
+
+  full(false);
+  setInterval(() => safe(fast), FAST_MS).unref();
+  setInterval(() => safe(() => full(true)), FULL_MS).unref();
+  return { watching: () => ({ sessions: activeSessions.size, projects: activeRoots.size }) };
+}

package/src/hub/lib/transcripts.mjs

@@ -0,0 +1,364 @@
+// agents-hub lib/transcripts.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// Cursor transcripts (~/.cursor/projects/*/agent-transcripts): who exists, who started whom, what each agent was
+// asked to do, and where a session's conversation stands.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { normRole } from './channels.mjs';
+
+export const PROJECTS = path.join(os.homedir(), '.cursor', 'projects');
+const HEAD_BYTES = 48 * 1024;
+const TAIL_BYTES = 256 * 1024;
+const REPO = /\/(agentpulse-[a-z0-9-]+|AgentforceVoice[A-Za-z0-9-]*)(?=[`'"\s/)]|$)/g;
+const CHANNEL_REF = /(?:([A-Za-z0-9._-]+)\/)?\.agents\/([A-Za-z0-9._-]+)\/channel\.md/g;
+const BRIEF = /You are (?:the |a |an )?([A-Z][A-Z-]+(?: [A-Z][A-Z-]+)?) for (?:[A-Za-z][A-Za-z ]* )?task ([A-Za-z0-9][A-Za-z0-9 ._-]*?)(?: \(([^)]{3,140})\))?[ ,.]/;
+
+const headCache = new Map();
+/** A transcript's first line (its brief). It never changes once written, so it is read once per file. */
+function head(file, st) {
+  const hit = headCache.get(file);
+  if (hit && hit.birth === st.birthtimeMs && hit.complete) return hit.line;
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buf = Buffer.alloc(HEAD_BYTES);
+    const n = fs.readSync(fd, buf, 0, HEAD_BYTES, 0);
+    const text = buf.subarray(0, n).toString('utf8');
+    const nl = text.indexOf('\n');
+    const line = nl >= 0 ? text.slice(0, nl) : text;
+    if (headCache.size > 5000) headCache.clear();
+    headCache.set(file, { birth: st.birthtimeMs, line, complete: nl >= 0 || n < HEAD_BYTES });
+    return line;
+  } finally { fs.closeSync(fd); }
+}
+
+/** "<timestamp>Thursday, Oct 8, 2026, 9:49 AM (UTC+5:30)" → epoch ms (local), or null. */
+export function parseStamp(s) {
+  const m = s && s.match(/<timestamp>\w+, ([A-Z][a-z]{2} \d{1,2}, \d{4}), (\d{1,2}:\d{2} [AP]M)/);
+  if (!m) return null;
+  const t = Date.parse(`${m[1]} ${m[2]}`);
+  return Number.isNaN(t) ? null : t;
+}
+
+const QUERY_CHARS = 16000;
+
+/** The agent's opening prompt (the Task brief), with tags stripped. */
+export function firstUserQuery(firstLine) {
+  if (!firstLine) return null;
+  const fromParts = (parts) => {
+    const texts = [];
+    if (typeof parts === 'string') texts.push(parts);
+    else if (Array.isArray(parts)) {
+      for (const p of parts) {
+        if (typeof p === 'string') texts.push(p);
+        else if (p && p.type === 'text' && typeof p.text === 'string') texts.push(p.text);
+      }
+    }
+    return texts.join('\n');
+  };
+  let joined = '';
+  try {
+    const obj = JSON.parse(firstLine);
+    joined = fromParts(obj.message && obj.message.content != null ? obj.message.content : obj.content);
+  } catch {
+    const m = firstLine.match(/<user_query>\\n([^]*?)(?:<\\\/user_query>|<\/user_query>|$)/);
+    if (!m) return null;
+    joined = m[1].replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\t/g, '\t');
+  }
+  const tagged = joined.match(/<user_query>\s*([\s\S]*?)<\/user_query>/);
+  const q = (tagged ? tagged[1] : joined).replace(/<timestamp>[\s\S]*?<\/timestamp>\s*/g, '').trim();
+  return q ? q.slice(0, QUERY_CHARS) : null;
+}
+
+/** The first user prompt saved in a transcript file. */
+export function queryFromTranscript(file) {
+  let st;
+  try { st = fs.statSync(file); } catch { return null; }
+  return firstUserQuery(head(file, st));
+}
+
+/**
+ * The longest CODER (else any) opening prompt that names this channel. Used when brief.md and the spec are missing.
+ */
+export function findAgentQuery(channelKey) {
+  const parts = String(channelKey || '').split('/');
+  if (parts.length !== 2) return null;
+  const [repo, task] = parts;
+  if (!/^[A-Za-z0-9._-]+$/.test(repo) || !/^[A-Za-z0-9._-]+$/.test(task)) return null;
+  let best = null;
+  eachTranscriptDir((dir) => {
+    const subs = path.join(dir, 'subagents');
+    let files = [];
+    try { files = fs.readdirSync(subs); } catch { return; }
+    for (const s of files) {
+      if (!s.endsWith('.jsonl')) continue;
+      const file = path.join(subs, s);
+      let st;
+      try { st = fs.statSync(file); } catch { continue; }
+      const line = head(file, st);
+      if (!line.includes(`${repo}/.agents/${task}/`) && !(line.includes(`.agents/${task}/`) && line.includes(`/${repo}`))) continue;
+      const q = firstUserQuery(line);
+      if (!q) continue;
+      const score = (/^You are (?:the |a |an )?CODER\b/m.test(q) ? 1e6 : 0) + q.length;
+      if (!best || score > best.score) best = { query: q, score };
+    }
+  });
+  return best ? best.query : null;
+}
+
+/** What a transcript's first message says about the agent: role, task, its channel and the repo it works in. */
+export function describe(firstLine) {
+  const q = (firstLine.match(/<user_query>\\n([^]{0,700})/) || [])[1] || '';
+  const text = q.replace(/\\n/g, ' ').replace(/\\"/g, '"').replace(/[`*#]/g, '').replace(/\s+/g, ' ').trim();
+  const role = (text.match(/^You are (?:the |a |an )?([A-Z][A-Z-]+(?: [A-Z][A-Z-]+)?)\b/) || [])[1] || (/^Thoroughness:/i.test(text) ? 'EXPLORER' : null);
+  const tm = text.match(/\btask ([A-Za-z0-9][A-Za-z0-9 ._-]*?)(?: \(([^)]{3,140})\)|,|\.|$)/);
+  const ch = [...firstLine.matchAll(CHANNEL_REF)][0];
+  const wt = firstLine.match(/worktree\s+(?:`([^`]+)`|'([^']+)'|\\?"([^"\\]+)\\?"|(\S+))/);
+  const worktree = wt ? path.basename((wt[1] || wt[2] || wt[3] || wt[4]).replace(/[).,]+$/, '')) : null;
+  const repos = [...firstLine.matchAll(REPO)].map((m) => m[1]);
+  const isRepo = (r) => !!r && /^(agentpulse-|AgentforceVoice)/.test(r);
+  const repoHint = [ch && ch[1], worktree, repos[0]].find(isRepo) || null;
+  return {
+    text, role: role ? normRole(role) : null, task: tm ? tm[1].trim() : null, taskTitle: tm && tm[2] ? tm[2].trim() : null,
+    channelTask: ch ? ch[2] : null, repo: repoHint,
+  };
+}
+
+/** The channel key ("<repo>/<task>") a task name refers to: unique by name, else the one in the hinted repo. */
+export function resolveKey(task, repoHint, index) {
+  const keys = (task && index.get(task)) || [];
+  if (keys.length === 1) return keys[0];
+  return keys.find((k) => repoHint && k.startsWith(`${repoHint}/`)) || null;
+}
+
+const shortLabel = (d) => (d.role ? d.role.toLowerCase().replace(/(^|\s)\w/g, (c) => c.toUpperCase()) : d.text.slice(0, 42) + (d.text.length > 42 ? '…' : ''));
+
+function nodeFrom(id, file, parent, st, index) {
+  const first = head(file, st);
+  const d = describe(first);
+  return {
+    id, kind: parent ? 'agent' : 'session', role: d.role, task: d.task, taskTitle: d.taskTitle, repo: d.repo,
+    channel: d.channelTask, channelKey: resolveKey(d.channelTask, d.repo, index),
+    label: shortLabel(d), title: d.text.slice(0, 200), parent, startedAt: parseStamp(first) || st.birthtimeMs, lastAt: st.mtimeMs, bytes: st.size, file,
+  };
+}
+
+function eachTranscriptDir(cb) {
+  let projects = [];
+  try { projects = fs.readdirSync(PROJECTS); } catch { return; }
+  for (const p of projects) {
+    const root = path.join(PROJECTS, p, 'agent-transcripts');
+    let dirs = [];
+    try { dirs = fs.readdirSync(root); } catch { continue; }
+    for (const d of dirs) cb(path.join(root, d), d);
+  }
+}
+
+const LAUNCH_INDEX_MS = 60e3;
+let launchIndex = { at: 0, map: new Map(), files: new Map() };
+/**
+ * Every subagent id and the session that launched it, from all `<session>/subagents/` folders whatever their age. A
+ * background subagent also has its own top-level transcript, which must never pass for a session of yours.
+ */
+export function launchedBy() {
+  if (Date.now() - launchIndex.at < LAUNCH_INDEX_MS) return launchIndex.map;
+  const map = new Map();
+  const files = new Map();
+  eachTranscriptDir((dir, d) => {
+    let subs = [];
+    try { subs = fs.readdirSync(path.join(dir, 'subagents')); } catch { return; }
+    for (const s of subs) if (s.endsWith('.jsonl') && s.slice(0, -6) !== d) map.set(s.slice(0, -6), d);
+    if (subs.length) files.set(d, path.join(dir, `${d}.jsonl`));
+  });
+  launchIndex = { at: Date.now(), map, files };
+  return map;
+}
+
+/** The top-level session a transcript id belongs to (itself, or the session that launched it), as a session node. */
+export function topSession(id, index) {
+  const launched = launchedBy();
+  let top = id;
+  for (let i = 0; launched.has(top) && i < 8; i++) top = launched.get(top);
+  if (top === id && !launched.has(id)) return null;
+  const file = launchIndex.files.get(top);
+  let st;
+  try { st = file && fs.statSync(file); } catch { return null; }
+  return st ? nodeFrom(top, file, null, st, index) : null;
+}
+
+/** Sessions and their subagents changed since sinceMs. A background subagent's launch stub and its own transcript merge. */
+export function scanTranscripts(sinceMs, index) {
+  const nodes = new Map();
+  const add = (id, file, parent) => {
+    let st;
+    try { st = fs.statSync(file); } catch { return; }
+    if (st.mtimeMs < sinceMs) return;
+    const n = nodeFrom(id, file, parent, st, index);
+    const prev = nodes.get(id);
+    if (prev) { n.parent = n.parent || prev.parent; n.bytes = Math.max(prev.bytes, n.bytes); n.lastAt = Math.max(prev.lastAt, n.lastAt); }
+    nodes.set(id, n);
+  };
+  /** A folder's own mtime changes only when entries are added; an appended transcript or a new stub is newer. */
+  const freshest = (...files) => Math.max(0, ...files.map((f) => { try { return fs.statSync(f).mtimeMs; } catch { return 0; } }));
+  eachTranscriptDir((dir, d) => {
+    let st;
+    try { st = fs.statSync(dir); } catch { return; }
+    if (!st.isDirectory()) return;
+    const subs = path.join(dir, 'subagents');
+    if (Math.max(st.mtimeMs, freshest(path.join(dir, `${d}.jsonl`), subs)) < sinceMs) return;
+    add(d, path.join(dir, `${d}.jsonl`), null);
+    let files = [];
+    try { files = fs.readdirSync(subs); } catch { return; }
+    for (const s of files) if (s.endsWith('.jsonl')) add(s.slice(0, -6), path.join(subs, s), d);
+  });
+  const groups = new Map();
+  for (const n of nodes.values()) if (n.role && (n.channelKey || n.channel)) {
+    const k = `${n.channelKey || n.channel}|${n.role}`;
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k).push(n);
+  }
+  for (const g of groups.values()) {
+    if (g.length < 2) continue;
+    g.sort((a, b) => b.bytes - a.bytes);
+    const [keep, ...rest] = g;
+    for (const r of rest) { keep.parent = keep.parent || r.parent; keep.startedAt = Math.min(keep.startedAt, r.startedAt); keep.lastAt = Math.max(keep.lastAt, r.lastAt); nodes.delete(r.id); }
+  }
+  const launched = launchedBy();
+  for (const n of [...nodes.values()]) {
+    const by = launched.get(n.id);
+    if (!by) continue;
+    n.kind = 'agent';
+    n.launchedBy = by;
+    if (!n.parent) n.parent = by;
+    if (nodes.has(by) || launched.has(by)) continue;
+    const file = launchIndex.files.get(by);
+    let st;
+    try { st = file && fs.statSync(file); } catch { st = null; }
+    if (st) nodes.set(by, nodeFrom(by, file, null, st, index));
+  }
+  for (const n of nodes.values()) if (n.parent && !nodes.has(n.parent)) n.parent = null;
+  return nodes;
+}
+
+/** Top-level sessions (not briefed agents) changed since sinceMs, for finding orchestrators that went quiet. */
+export function scanSessions(sinceMs, index) {
+  const out = [];
+  eachTranscriptDir((dir, d) => {
+    const file = path.join(dir, `${d}.jsonl`);
+    let st;
+    try { st = fs.statSync(file); } catch { return; }
+    if (st.mtimeMs < sinceMs) return;
+    const n = nodeFrom(d, file, null, st, index);
+    if (n.kind === 'session') out.push(n);
+  });
+  return out;
+}
+
+const ownCache = new Map();
+const READ_CHUNK = 4 * 1024 * 1024;
+
+function ownedRefsFromLine(line, list) {
+  if (!line.includes('channel.md') || !line.includes('"tool_use"')) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+  for (const b of (msg.message && msg.message.content) || []) {
+    if (b.type !== 'tool_use') continue;
+    const tool = (b.input && b.input.toolName) || b.name;
+    const input = JSON.stringify(b.input || {});
+    const owns = tool === 'Task' || tool === 'Write' || (tool === 'Shell' && /cat\s*>>?[^|]*channel\.md|>>\s*"?[^"\s]*channel\.md/.test(input));
+    if (!owns) continue;
+    const repos = [...input.matchAll(REPO)].map((m) => m[1]);
+    const brief = tool === 'Task' ? input.match(BRIEF) : null;
+    for (const m of input.matchAll(CHANNEL_REF)) {
+      list.push({ task: m[2], repo: m[1] && m[1] !== '.agents' ? m[1] : null, repos,
+        brief: brief ? { role: normRole(brief[1]), code: brief[2].trim(), title: brief[3] ? brief[3].trim() : null } : null });
+    }
+  }
+}
+
+/** Drop cached scans of transcripts that have not changed since cutoffMs (outside every window the hub looks at). */
+export function pruneOwnCache(cutoffMs) { for (const [k, v] of ownCache) if (v.mtime < cutoffMs) ownCache.delete(k); }
+
+/**
+ * Channel keys a session owns: named in a subagent brief (Task) or written by it (Write, or a Shell append). Reading a
+ * channel does not count. Transcripts only grow, so each is scanned incrementally from where the last scan stopped;
+ * the found (task, repos) pairs resolve to keys against the current index.
+ */
+export function channelsOwned(file, index) {
+  let refs = ownCache.get(file);
+  try {
+    const st = fs.statSync(file);
+    if (!refs || st.size < refs.offset) refs = { offset: 0, rest: '', list: [], decoder: new StringDecoder('utf8'), mtime: 0 };
+    refs.mtime = st.mtimeMs;
+    if (st.size > refs.offset) {
+      const fd = fs.openSync(file, 'r');
+      try {
+        while (refs.offset < st.size) {
+          const len = Math.min(READ_CHUNK, st.size - refs.offset);
+          const buf = Buffer.alloc(len);
+          const n = fs.readSync(fd, buf, 0, len, refs.offset);
+          if (!n) break;
+          refs.offset += n;
+          const lines = (refs.rest + refs.decoder.write(buf.subarray(0, n))).split('\n');
+          refs.rest = lines.pop();
+          for (const line of lines) ownedRefsFromLine(line, refs.list);
+        }
+      } finally { fs.closeSync(fd); }
+    }
+    ownCache.set(file, refs);
+  } catch { refs = refs || { offset: 0, rest: '', list: [], mtime: 0 }; }
+  const keys = new Set();
+  const briefs = new Map();
+  for (const r of refs.list) {
+    const k = resolveKey(r.task, r.repo, index) || r.repos.map((repo) => resolveKey(r.task, repo, index)).find(Boolean);
+    if (!k) continue;
+    keys.add(k);
+    if (r.brief) { if (!briefs.has(k)) briefs.set(k, new Map()); briefs.get(k).set(r.brief.role, r.brief); }
+  }
+  keys.briefs = briefs;
+  return keys;
+}
+
+const tailCache = new Map();
+/** Where a session's conversation stands, from the end of its transcript; re-read only when the file grew. */
+export function sessionTail(file) {
+  let size = -1;
+  try { size = fs.statSync(file).size; } catch { return { state: 'unknown', lastText: '' }; }
+  const hit = tailCache.get(file);
+  if (hit && hit.size === size) return hit.tail;
+  const tail = readTail(file);
+  if (tailCache.size > 2000) tailCache.clear();
+  tailCache.set(file, { size, tail });
+  return tail;
+}
+
+function readTail(file) {
+  let text = '';
+  try {
+    const st = fs.statSync(file);
+    const fd = fs.openSync(file, 'r');
+    const len = Math.min(TAIL_BYTES, st.size);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, st.size - len);
+    fs.closeSync(fd);
+    text = buf.toString('utf8');
+  } catch { return { state: 'unknown', lastText: '' }; }
+  const lines = text.split('\n').filter(Boolean).slice(1).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  const last = lines[lines.length - 1];
+  let lastText = '';
+  for (let i = lines.length - 1; i >= 0 && !lastText; i--) {
+    const m = lines[i];
+    if (m.role === 'assistant') lastText = (m.message.content || []).filter((c) => c.type === 'text').map((c) => c.text).join(' ').trim();
+  }
+  if (!last) return { state: 'unknown', lastText };
+  if (last.type === 'turn_ended') return { state: 'turn-ended', lastText };
+  if (last.role === 'assistant') {
+    const ask = [...(last.message.content || [])].reverse().find((c) => c.type === 'tool_use');
+    if (ask && /AskQuestion$/.test(ask.name || (ask.input && ask.input.toolName) || '')) {
+      const qs = (ask.input.questions || (ask.input.arguments && ask.input.arguments.questions) || []);
+      const q = qs[0] || {};
+      return { state: 'asking', lastText, question: { title: ask.input.title || null, prompt: q.prompt || '', options: (q.options || []).map((o) => o.label), more: Math.max(0, qs.length - 1) } };
+    }
+  }
+  return { state: 'working', lastText };
+}

package/src/hub/lib/writing.mjs

@@ -0,0 +1,18 @@
+// agents-hub lib/writing.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// How agents write anything a person reads in the hub: channel posts, replies and side-chat answers. The hub renders
+// GitHub-flavoured markdown, so structure shows up as real lists, code blocks and tables.
+
+/** One paragraph for prompts and hook messages. */
+export const WRITING_GUIDE = 'Write in GitHub markdown so the hub renders it cleanly: lead with the outcome in one plain sentence; '
+  + 'short paragraphs separated by a blank line; `- ` bullets for three or more items and `1.` for steps; '
+  + 'file paths, commands, ids and short code in `backticks`; multi-line code, logs or output in fenced blocks with a language '
+  + '(```js … ```); a table when comparing items (file | status | note); no HTML.';
+
+/** How to ask the user for a decision so the hub raises it to them (Deliveries, Board, desktop notification). */
+export const DECISION_RULE = 'When a decision needs the user, tag them: write `NEEDS USER` in the post header and `@you` in the body, '
+  + 'say what must be decided in one sentence, then list the choices as `(a) …`, `(b) …` with your recommendation and its cost. '
+  + 'Keep working on anything that does not depend on the answer; their reply arrives as a USER DECISION post.';
+
+/** Extra rule for task-channel posts, whose header line the hub parses. */
+export const CHANNEL_POST_RULE = 'In a channel post keep the header line exactly `## [ROLE] HH:MM:SS TYPE — summary`; inside the body use '
+  + '`###` headings or **bold** labels, and never start a body line with `## [` (that would begin a new post).';

package/src/hub/projections/deliveries.mjs

@@ -0,0 +1,31 @@
+// agents-hub projections/deliveries.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// Pure read of delivery and agent-row facts. One display title per delivery (cursor_title). A status you set
+// (status_override facts, lib/status.mjs) and a card you moved to a step are applied over the derived ones here, so
+// every reader sees the same.
+import { displayTitle } from '../core/ids.mjs';
+import { withOverride, withSteps, workMoved } from '../lib/status.mjs';
+
+export function projectDeliveries(hub) {
+  const { registry } = hub;
+  const overrides = new Map(registry.facts('status_override').map(({ key, updated_at: _at, ...o }) => [key, o]));
+  const deliveries = registry.facts('delivery').filter((d) => {
+    const actor = registry.get(d.id);
+    return !actor || actor.node_type === 'orchestrator';
+  }).map((d) => {
+    const actor = registry.get(d.id);
+    const name = actor ? displayTitle(actor) : (d.name || d.title);
+    const moved = withSteps({ ...d, name, displayTitle: name }, (key) => overrides.get(`stream:${key}`));
+    return withOverride(moved, overrides.get(`delivery:${d.id}`), { kind: 'delivery', ...workMoved('delivery', d) });
+  });
+  const agents = registry.facts('agent-row').filter((a) => {
+    const actor = a.isArchitect && registry.get(a.id);
+    return !actor || actor.node_type === 'orchestrator';
+  }).map((a) => {
+    const actor = registry.get(a.id);
+    const title = actor ? displayTitle(actor) : (a.persona && a.persona.name) || a.label;
+    const delivery = deliveries.find((d) => d.id === a.deliveryId);
+    const row = { ...a, displayTitle: title, deliveryTitle: delivery ? delivery.displayTitle || delivery.name : a.deliveryTitle };
+    return withOverride(row, overrides.get(`agent:${a.id}`), { kind: 'agent', ...workMoved('agent', a) });
+  });
+  return { deliveries, agents };
+}

package/src/hub/projections/graph.mjs

@@ -0,0 +1,149 @@
+// agents-hub projections/graph.mjs at 6b2fb0b. Ported verbatim; every change is a declared seam (test/hub-verbatim.test.js).
+// Pure read: actors + presence + messages + discovery facts. Writes nothing.
+import { displayTitle, managerChats } from '../core/ids.mjs';
+import { projectDeliveries } from './deliveries.mjs';
+
+const ACTIVE_MS = 10 * 60e3;
+const IDLE_MS = 60 * 60e3;
+
+function statusFrom(lastAt, presence, now) {
+  if (presence && now - presence.last_seen < 3 * 60e3 && presence.last_event !== 'stop') return 'active';
+  if (now - lastAt < ACTIVE_MS) return 'active';
+  if (now - lastAt < IDLE_MS) return 'idle';
+  return 'done';
+}
+
+function kindOf(a) {
+  if (a.node_type === 'user') return 'user';
+  if (a.node_type === 'manager') return 'manager';
+  if (a.node_type === 'orchestrator') return 'session';
+  return 'agent';
+}
+
+/**
+ * Header totals for one window from the canonical pass's basis (lib/collect.mjs totalsBasis): the people seen since
+ * `since`, the tokens of those whose own transcript is active since then, and the messages sent since then.
+ */
+function windowTotals(basis, since, now, requests) {
+  const people = basis.people.filter(([, seenAt]) => seenAt >= since);
+  return {
+    sessions: people.filter(([kind]) => kind === 's').length,
+    agents: people.filter(([kind]) => kind === 'a').length,
+    active: people.filter(([, , lastAt]) => now - lastAt < ACTIVE_MS).length,
+    messages: basis.messages.reduce((sum, [at, count]) => sum + (at >= since ? count : 0), 0),
+    tokensEst: people.reduce((sum, [, , lastAt, tokens]) => sum + (lastAt >= since ? tokens : 0), 0),
+    requests,
+  };
+}
+
+export function projectGraph(hub, { hours = 24, managerView = {}, now = Date.now() } = {}) {
+  const { registry, messaging } = hub;
+  const since = now - hours * 3600e3;
+  const presences = registry.presences();
+  // Delivery and agent rows are canonical (workers/collector.mjs CANONICAL_HOURS); a window only picks the rows
+  // active in it. A row without lastAt is kept.
+  const inWindow = (row) => !Number.isFinite(row.lastAt) || Math.max(row.lastAt, Number(row.movedAt) || 0) >= since;
+  const projected = projectDeliveries(hub);
+  const deliveries = projected.deliveries.filter(inWindow).sort((a, b) => (b.lastAt || 0) - (a.lastAt || 0));
+  const agents = projected.agents.filter(inWindow);
+  const requests = registry.facts('request').filter((r) => (r.at || 0) >= since);
+
+  const ownChats = managerChats(registry.fact('manager', 'config'));
+  const nodes = registry.all().filter((a) => {
+    if (ownChats.has(a.id)) return false;
+    if (!((a.last_at || 0) >= since || a.id === 'user' || a.id === 'manager' || presences.has(a.id))) return false;
+    // Bus addresses like repo/task:ROLE are channel participants, not sessions.
+    if (a.node_type === 'orchestrator' && /[/:]/.test(a.id)) return false;
+    return true;
+  }).map((a) => {
+    const p = presences.get(a.id);
+    const lastAt = Math.max(a.last_at || 0, p ? p.last_seen : 0, a.id === 'user' ? now : 0);
+    const persona = a.persona || (a.persona_name ? {
+      name: a.persona_name, first: a.persona_first, username: a.persona_username, seed: a.persona_seed, personality: a.persona,
+    } : null);
+    const title = displayTitle(a);
+    return {
+      id: a.id,
+      kind: kindOf(a),
+      node_type: a.node_type,
+      role: a.role,
+      label: title,
+      title,
+      chatTitle: a.cursor_title || null,
+      promptTitle: a.prompt_title || null,
+      displayTitle: title,
+      parent: a.parent_id,
+      deliveryId: a.delivery_id || (a.node_type === 'orchestrator' ? a.id : a.parent_id),
+      deliveryTitle: a.node_type === 'orchestrator' ? title : null,
+      channelKey: a.stream_key,
+      channel: a.channel,
+      repo: a.repo,
+      project: a.repo,
+      taskTitle: a.prompt_title,
+      startedAt: a.started_at || lastAt,
+      lastAt,
+      status: a.id === 'manager'
+        ? (managerView.state === 'working' ? 'active' : managerView.online ? 'idle' : 'done')
+        : statusFrom(lastAt, p, now),
+      tokensEst: a.tokens_est,
+      msgsIn: a.msgs_in, msgsOut: a.msgs_out,
+      persona,
+      busAddress: a.id,
+      busOnline: !!(p && now - (p.last_seen || 0) < 90e3),
+      synthetic: !!a.synthetic,
+    };
+  });
+
+  const byId = new Set(nodes.map((n) => n.id));
+  const links = [];
+  const linkKeys = new Set();
+  for (const n of nodes) {
+    if (n.parent && byId.has(n.parent)) {
+      links.push({ source: n.parent, target: n.id, kind: 'spawn', count: 1 });
+      linkKeys.add(`${n.parent}|${n.id}|spawn`);
+    }
+  }
+  const events = [];
+  for (const message of messaging.messages({ since, limit: 300 })) {
+    for (const to of message.to || []) {
+      events.push({
+        at: message.at, from: message.from, to, type: message.type, text: message.body,
+        messageId: message.id, topic: message.topic, bus: true,
+      });
+      if (!byId.has(message.from) || !byId.has(to) || message.from === to) continue;
+      const key = `${message.from}|${to}|bus`;
+      if (!linkKeys.has(key)) { links.push({ source: message.from, target: to, kind: 'bus', count: 1 }); linkKeys.add(key); }
+      else {
+        const link = links.find((l) => `${l.source}|${l.target}|${l.kind}` === key);
+        if (link) link.count++;
+      }
+    }
+  }
+  const channelEvents = registry.eventsSince(since, 400).filter((e) => !e.bus);
+  const allEvents = [...channelEvents.map((e) => ({
+    at: e.at, from: e.from || e.actor, to: e.to, type: e.type || e.kind, text: e.text, channel: e.channel,
+  })), ...events].filter((e) => e && e.at).sort((a, b) => a.at - b.at);
+
+  const people = nodes.filter((n) => n.kind !== 'manager');
+  const basis = registry.fact('totals', 'basis');
+  return {
+    generatedAt: now,
+    hours,
+    deliveries,
+    agents,
+    nodes,
+    links,
+    events: allEvents.slice(-400),
+    requests,
+    totals: basis ? windowTotals(basis, since, now, requests.length) : {
+      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: allEvents.length,
+      tokensEst: people.reduce((s, n) => s + (n.tokensEst || 0), 0),
+      requests: requests.length,
+    },
+    manager: managerView,
+    bus: { messages: messaging.messages({ since, limit: 300 }), registrations: registry.registrations(now) },
+  };
+}