huddle-cli 0.0.0-stage → 0.1.0

package/dist/ui/story.js

@@ -0,0 +1,932 @@
+// `huddle story` — one place to SEE a run's collaboration, after the fact.
+//
+// Everything comes from the Room db's event table (.huddle/huddle.db): the plan
+// (task.added + plan.made), the scheduler's own events (persisted as run.*),
+// agents' messages, questions and answers, announced plans, shared memory,
+// reviews, merges — and whatever newer phases write (council.*, takeover,
+// split, qa.*). Known types get a sentence; any other type is still shown,
+// generically, with its fields, so nothing a run recorded is ever lost.
+//
+//   huddle story                  the latest run, as a timeline + who-did-what
+//   huddle story --list           every run in this repo's room
+//   huddle story --run <n|id>     one run (number from --list, or session id)
+//   huddle story --html out.html  a self-contained static report (lanes, threads)
+import fs from "node:fs";
+import path from "node:path";
+import { C, dot, pad, AGENT_COLOR } from "./term.js";
+import { fmtDuration, fmtTokens } from "../adapters/usage.js";
+import { isHelpOffer } from "../room/progress.js";
+/** The scheduler's own event types, persisted as "run.<type>" (scheduler.ts). */
+const CORE_RUN = new Set(["start", "declined", "tokens", "review", "reviewed", "merged", "failed", "stuck", "conflict", "resolved", "handoff"]);
+const NOT_AGENTS = new Set(["huddle", "room", "all", "you", "council", ""]);
+function parse(e) {
+    let p = {};
+    try {
+        const v = JSON.parse(e.payload || "{}");
+        if (v && typeof v === "object" && !Array.isArray(v))
+            p = v;
+        else
+            p = { value: v };
+    }
+    catch {
+        p = { payload: e.payload };
+    }
+    let type = e.type;
+    if (type.startsWith("run.") && !CORE_RUN.has(type.slice(4)))
+        type = type.slice(4);
+    if (type !== e.type && p.type === e.type.slice(4))
+        delete p.type;
+    if (e.type.startsWith("run."))
+        delete p.type;
+    return { ts: e.ts, type, agent: e.agent_id, task: e.task_id, p };
+}
+const str = (v) => (v === undefined || v === null ? "" : typeof v === "string" ? v : typeof v === "object" ? JSON.stringify(v) : String(v));
+/** First non-empty field among `keys`. */
+const pick = (p, ...keys) => {
+    for (const k of keys) {
+        const v = p[k];
+        if (v !== undefined && v !== null && str(v).trim())
+            return str(v);
+    }
+    return "";
+};
+const oneLine = (s, n = 140) => {
+    const l = s.replace(/\s+/g, " ").trim();
+    return l.length <= n ? l : l.slice(0, n - 1) + "…";
+};
+/**
+ * A goal as a headline. Found on the capstone: a 3.5 KB project brief was the
+ * STORY line (and the list row, and the page's <h1>), escaped quotes and all.
+ * Its first line, capped; the full brief stays in the HTML under "The goal".
+ */
+export const goalTitle = (goal, n = 160) => oneLine(goal.split(/\n/)[0] ?? "", n);
+/**
+ * "(didn't write it)" only when that's true. Found live (capstone round 3):
+ * every agent had written code, QA said "checking anyway", and the story still
+ * claimed fresh eyes. Older runs (no `authors` on qa.round) keep the old line.
+ */
+function qaEyes(checkers, authors) {
+    if (authors === undefined)
+        return "(didn't write it)";
+    const wrote = new Set(list(authors));
+    const mine = checkers.filter((a) => wrote.has(a));
+    if (!mine.length)
+        return "(didn't write it)";
+    return mine.length === checkers.length ? "(wrote some of it too — checking anyway)" : `(${mine.join(", ")} wrote some of it too)`;
+}
+const list = (v) => {
+    if (Array.isArray(v))
+        return v.map(str);
+    if (typeof v === "string") {
+        try {
+            const j = JSON.parse(v);
+            if (Array.isArray(j))
+                return j.map(str);
+        }
+        catch {
+            /* plain string */
+        }
+        return v ? [v] : [];
+    }
+    return [];
+};
+/**
+ * Cut the event log into runs. A run starts at the board.cleared just before
+ * its session.created (one goal = one board); council.* events written before
+ * that board was cleared belong to the run they designed. A room with no goals
+ * (attach mode) is one run.
+ */
+export function splitRuns(raw) {
+    const evs = raw.map(parse);
+    const anchors = evs.map((e, i) => (e.type === "session.created" ? i : -1)).filter((i) => i >= 0);
+    const mk = (index, events, s) => ({
+        index,
+        id: s ? str(s.p.id) || null : null,
+        goal: s ? str(s.p.goal) : "(no goal — attach sessions)",
+        start: events[0]?.ts ?? 0,
+        end: events.at(-1)?.ts ?? 0,
+        events,
+    });
+    if (!anchors.length)
+        return evs.length ? [mk(1, evs)] : [];
+    const starts = anchors.map((a, k) => {
+        const floor = k ? anchors[k - 1] + 1 : 0;
+        for (let i = a; i >= floor; i--)
+            if (evs[i].type === "board.cleared")
+                return i;
+        return a;
+    });
+    const chunks = starts.map((s, k) => evs.slice(s, k + 1 < starts.length ? starts[k + 1] : evs.length));
+    // The design talk happens before the board is cleared: move it forward.
+    const isDesign = (e) => e.type.startsWith("council.");
+    const before = evs.slice(0, starts[0]).filter(isDesign);
+    chunks[0] = [...before, ...chunks[0]];
+    for (let k = 1; k < chunks.length; k++) {
+        const prev = chunks[k - 1];
+        let cut = prev.length;
+        while (cut > 0 && isDesign(prev[cut - 1]))
+            cut--;
+        if (cut < prev.length) {
+            chunks[k] = [...prev.slice(cut), ...chunks[k]];
+            chunks[k - 1] = prev.slice(0, cut);
+        }
+    }
+    return chunks.map((c, k) => mk(k + 1, c, evs[anchors[k]]));
+}
+/** Pick a run: latest by default, else its number (from --list) or session id. */
+export function pickRun(runs, which) {
+    if (!which)
+        return runs.at(-1);
+    const n = Number(which);
+    if (Number.isInteger(n))
+        return n > 0 ? runs.find((r) => r.index === n) : runs.at(n - 1); // 0 = latest, -1 = the one before
+    return runs.find((r) => r.id === which);
+}
+const newStats = () => ({
+    merged: 0,
+    failed: 0,
+    reviews: 0,
+    changesAsked: 0,
+    sent: 0,
+    received: 0,
+    proposals: 0,
+    critiques: 0,
+    bugsFound: 0,
+    bugsFixed: 0,
+    takeoversIn: 0,
+    takeoversOut: 0,
+    toolCalls: 0,
+    ms: 0,
+    tokens: 0,
+    cached: 0,
+});
+export function buildStory(run, runs = 1) {
+    const titles = new Map();
+    const owner = new Map(); // task -> agent on it now
+    const agents = [];
+    const stats = new Map();
+    const talk = new Map();
+    const threads = new Map();
+    const items = [];
+    const design = [];
+    const spans = [];
+    const plan = { tasks: [] };
+    const open = new Map(); // agent -> its open span
+    const councilTasks = [];
+    let merged = 0;
+    let failed = 0;
+    // The brain that settles a council plan (a label like "claude · sonnet") is not an agent on the crew.
+    const working = new Set(run.events.filter((e) => e.type === "run.start" || e.type === "agent.joined").map((e) => e.agent));
+    const brains = new Set(run.events.filter((e) => e.type === "council.plan").map((e) => pick(e.p, "by")).filter((b) => b && !working.has(b)));
+    const isAgent = (a) => !!a && !NOT_AGENTS.has(a) && !brains.has(a);
+    const see = (a) => {
+        if (!isAgent(a))
+            return;
+        if (!agents.includes(a))
+            agents.push(a);
+        if (!stats.has(a))
+            stats.set(a, newStats());
+    };
+    const st = (a) => {
+        see(a);
+        return (isAgent(a) && stats.get(a)) || newStats();
+    };
+    const talked = (from, to) => {
+        if (!isAgent(from) || !isAgent(to) || from === to)
+            return;
+        see(from);
+        see(to);
+        const row = talk.get(from) ?? new Map();
+        row.set(to, (row.get(to) ?? 0) + 1);
+        talk.set(from, row);
+    };
+    const thread = (it) => {
+        if (!it.agent || !it.to)
+            return;
+        const key = [it.agent, it.to].sort().join(" ↔ ");
+        threads.set(key, [...(threads.get(key) ?? []), it]);
+    };
+    const title = (task, p) => pick(p ?? {}, "title") || (task ? titles.get(task) ?? task : "");
+    const q = (s) => (s ? `“${s}”` : "");
+    const close = (agent, ts, outcome) => {
+        const s = open.get(agent);
+        if (!s)
+            return;
+        s.to = Math.max(ts, s.from);
+        if (outcome)
+            s.outcome = outcome;
+        open.delete(agent);
+    };
+    const begin = (s) => {
+        close(s.agent, s.from);
+        const span = { ...s, to: run.end };
+        spans.push(span);
+        open.set(s.agent, span);
+    };
+    const add = (it) => {
+        see(it.agent);
+        (it.kind === "design" ? design : items).push(it);
+    };
+    const hasRun = run.events.some((e) => e.type.startsWith("run."));
+    // The scheduler's "takeover" and the Room's "task.takeover" describe the same handover;
+    // when the Room's is there it tells the story and the scheduler's only carries the cost.
+    const roomTakeovers = run.events.some((e) => e.type === "task.takeover");
+    const firstWork = run.events.find((e) => e.type === "run.start" || e.type === "task.claimed")?.ts ?? Infinity;
+    const recent = [];
+    for (const e of run.events) {
+        const p = e.p;
+        const ts = e.ts;
+        // The same phase may be written twice (a Room event and a scheduler event): show it once.
+        if (/^(council\.|takeover|split|task\.takeover|task\.split|qa\.)/.test(e.type)) {
+            // round + agents: two QA rounds a second apart are two rounds (mock capstone: round 2's line vanished).
+            const sig = [e.type, e.task, pick(p, "from", "agent", "by") || e.agent, pick(p, "to"), oneLine(pick(p, "title", "summary", "body", "reason"), 60), p.round === undefined ? "" : str(p.round), list(p.agents).join(",")].join("|");
+            if (recent.some((r) => r.sig === sig && ts - r.ts < 2000))
+                continue;
+            recent.push({ sig, ts });
+        }
+        switch (e.type) {
+            case "session.created":
+            case "board.cleared":
+            case "agent.status":
+            case "handoff.ready":
+            case "run.tokens":
+            case "run.handoff": // the Room's own "handoff" event says the same, with the files
+                break;
+            case "agent.joined":
+                see(e.agent ?? pick(p, "id"));
+                break;
+            case "plug.call":
+                st(e.agent).toolCalls++;
+                break;
+            case "plan.made":
+                plan.by = pick(p, "by") || plan.by;
+                plan.note = pick(p, "note") || plan.note;
+                break;
+            case "task.added": {
+                const id = pick(p, "id") || e.task || "";
+                const t = pick(p, "title");
+                titles.set(id, t);
+                if (ts <= firstWork) {
+                    plan.tasks.push({
+                        id,
+                        title: t,
+                        deps: list(p.depends_on),
+                        prefers: list(p.prefers),
+                        files: list(p.files),
+                        by: pick(p, "proposed_by", "by", "author") || undefined,
+                    });
+                }
+                else {
+                    const by = pick(p, "proposed_by", "by", "author", "filed_by");
+                    add({ ts, kind: "task", type: e.type, agent: isAgent(by) ? by : null, text: `new task on the board: ${q(t)}`, detail: oneLine(pick(p, "spec"), 200) });
+                }
+                break;
+            }
+            case "task.claimed": {
+                if (e.task && e.agent)
+                    owner.set(e.task, e.agent);
+                see(e.agent);
+                const viaScheduler = run.events.some((x) => x.type === "run.start" && x.task === e.task && x.agent === e.agent && Math.abs(x.ts - ts) < 3000);
+                if (!viaScheduler)
+                    add({ ts, kind: "task", type: e.type, agent: e.agent, text: `claims ${q(title(e.task))}` });
+                break;
+            }
+            case "task.progress": {
+                const note = pick(p, "note");
+                if (!note)
+                    break;
+                add({ ts, kind: "progress", type: e.type, agent: (e.task && owner.get(e.task)) || null, text: `${String(p.pct ?? "?").padStart(3)}% ${oneLine(note)}`, detail: q(title(e.task)) });
+                break;
+            }
+            case "task.status": {
+                if (hasRun)
+                    break; // the scheduler's run.* events tell it better
+                const s = pick(p, "status");
+                if (["merged", "failed", "needs_you"].includes(s)) {
+                    const who = (e.task && owner.get(e.task)) || null;
+                    if (s === "merged")
+                        merged++;
+                    else
+                        failed++;
+                    add({ ts, kind: s === "merged" ? "merge" : "fail", type: e.type, agent: who, text: `${s === "merged" ? "✓ merged" : s === "failed" ? "✗ failed" : "! needs you"} ${q(title(e.task))}` });
+                }
+                break;
+            }
+            case "plan.announced": {
+                const touches = list(p.touches);
+                const hits = Array.isArray(p.conflicts) ? p.conflicts : [];
+                add({
+                    ts,
+                    kind: "announce",
+                    type: e.type,
+                    agent: e.agent,
+                    text: `announces: ${oneLine(pick(p, "intent"), 110)}${touches.length ? ` · touches ${touches.slice(0, 5).join(", ")}${touches.length > 5 ? "…" : ""}` : ""}`,
+                    detail: hits.length ? `overlaps: ${hits.map((h) => `${str(h.path)} (held by ${str(h.held_by)})`).join(", ")}` : undefined,
+                });
+                see(e.agent);
+                break;
+            }
+            case "memory.added": {
+                const author = pick(p, "author") || e.agent || "";
+                const body = pick(p, "body");
+                if (author === "huddle") {
+                    // Mostly the scheduler restating what run.* says; the red gate is news.
+                    if (/red test gate/.test(body))
+                        add({ ts, kind: "fail", type: e.type, agent: null, text: oneLine(body) });
+                    break;
+                }
+                if (/^Review of /.test(body))
+                    break; // the verdict is the review item
+                const kind = pick(p, "kind") || "note";
+                const done = /^Task \S+ done:\s*/.exec(body);
+                add({
+                    ts,
+                    kind: done ? "task" : "memory",
+                    type: e.type,
+                    agent: author,
+                    text: done ? `done: ${oneLine(body.slice(done[0].length))}` : `${kind === "decision" && /contract/i.test(body) ? "contract" : kind}: ${oneLine(body)}`,
+                    detail: pick(p, "why") ? `why: ${oneLine(pick(p, "why"), 200)}` : undefined,
+                });
+                see(author);
+                break;
+            }
+            case "agent.message":
+            case "note": {
+                const from = pick(p, "from") || e.agent || "?";
+                const to = pick(p, "to") || "?";
+                const kind = pick(p, "kind") || "note";
+                // Huddle's automatic help offer, sent in a free agent's name: a board event,
+                // not a message the agent wrote. Found live (capstone round 2): 6 offers
+                // and no real message, yet the table said claude sent 3 messages.
+                if (isHelpOffer(from, pick(p, "body"))) {
+                    const t = /your task "(.*)" \(/.exec(pick(p, "body"))?.[1];
+                    add({ ts, kind: "task", type: "offer", agent: from, to, text: `is free: Huddle offers ${to} help${t ? ` with ${q(t)}` : ""} (huddle_split to hand off a part)` });
+                    break;
+                }
+                const it = { ts, kind: "message", type: e.type, agent: from, to, text: oneLine(pick(p, "body"), 400), detail: kind === "note" ? undefined : kind };
+                add(it);
+                thread(it);
+                st(from).sent++;
+                st(to).received++;
+                talked(from, to);
+                break;
+            }
+            case "ask": {
+                if (p.routed)
+                    break; // it's also an agent.message (kind question)
+                const from = pick(p, "from") || e.agent || "?";
+                const to = pick(p, "to") || "room";
+                const it = { ts, kind: "message", type: e.type, agent: from, to, text: oneLine(pick(p, "question"), 400), detail: "question" };
+                add(it);
+                st(from).sent++;
+                if (isAgent(to)) {
+                    st(to).received++;
+                    talked(from, to);
+                    thread(it);
+                }
+                break;
+            }
+            case "answer": {
+                if (pick(p, "source") === "teammate")
+                    break; // it's also an agent.message (kind answer)
+                const from = pick(p, "from") || "room";
+                const to = pick(p, "to");
+                add({ ts, kind: "message", type: e.type, agent: from, to, text: oneLine(pick(p, "answer"), 400), detail: `answer · ${pick(p, "source") || "shared memory"}` });
+                if (isAgent(to))
+                    st(to).received++;
+                break;
+            }
+            case "handoff": {
+                const from = pick(p, "from") || e.agent;
+                const to = pick(p, "to");
+                const files = list(p.files);
+                add({ ts, kind: "handoff", type: e.type, agent: from, to: to && to !== from ? to : null, text: `hands off ${q(pick(p, "title"))} · ${files.length} file(s), ${list(p.symbols).length} export(s)`, detail: files.slice(0, 6).join(", ") || undefined });
+                talked(from, to);
+                break;
+            }
+            case "message":
+                add({ ts, kind: "team", type: e.type, agent: null, text: `${pick(p, "from")} (person): ${oneLine(pick(p, "body"), 300)}` });
+                break;
+            case "member.joined":
+                add({ ts, kind: "team", type: e.type, agent: null, text: `${pick(p, "github") ? "@" + pick(p, "github") : pick(p, "name")} joined the room as ${pick(p, "role") || "member"}` });
+                break;
+            case "member.left":
+                add({ ts, kind: "team", type: e.type, agent: null, text: `${pick(p, "name")} ${pick(p, "reason") || "left"}` });
+                break;
+            case "crew.updated":
+                add({ ts, kind: "team", type: e.type, agent: null, text: `${pick(p, "member")}'s crew: ${list(p.agents).join(", ") || "(none)"}` });
+                break;
+            case "assign":
+                add({ ts, kind: "task", type: e.type, agent: e.agent, text: `offered ${q(pick(p.task ?? {}, "title") || title(e.task))} on ${pick(p, "worker") || "a teammate"}'s machine` });
+                break;
+            case "live.joined":
+                see(e.agent);
+                add({ ts, kind: "team", type: e.type, agent: e.agent, text: `joined live${pick(p, "branch") ? " on " + pick(p, "branch") : ""}` });
+                break;
+            case "live.left":
+                add({ ts, kind: "team", type: e.type, agent: e.agent, text: `left${pick(p, "why") ? " · " + pick(p, "why") : ""}` });
+                break;
+            case "live.released":
+                add({ ts, kind: "announce", type: e.type, agent: e.agent, text: `released ${list(p.paths).join(", ")}` });
+                break;
+            // ---- the scheduler ----
+            case "run.start": {
+                const a = pick(p, "agent") || e.agent || "?";
+                if (e.task)
+                    owner.set(e.task, a);
+                const t = title(e.task, p);
+                begin({ agent: a, from: ts, kind: "task", label: (p.fixing ? "fix: " : "") + t });
+                add({ ts, kind: "task", type: e.type, agent: a, text: `${p.fixing ? "▸ fix round on" : "▸ starts"} ${q(t)}${p.remote ? ` · on ${pick(p, "remote")}'s machine` : ""}` });
+                break;
+            }
+            case "run.declined":
+                add({ ts, kind: "task", type: e.type, agent: pick(p, "agent") || e.agent, text: `declined ${q(title(e.task, p))} · back on the board` });
+                break;
+            case "run.review": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                close(author, ts, undefined);
+                begin({ agent: a, from: ts, kind: "review", label: `review ${author}` });
+                add({ ts, kind: "review", type: e.type, agent: a, to: author, text: `◎ reviews ${author}'s ${q(title(e.task, p))}` });
+                break;
+            }
+            case "run.reviewed": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                const s = st(a);
+                s.reviews++;
+                s.ms += Number(p.ms) || 0;
+                if (p.approve === false)
+                    s.changesAsked++;
+                close(a, ts, p.skipped ? "warn" : p.approve === false ? "bad" : "ok");
+                const notes = pick(p, "notes");
+                const it = {
+                    ts,
+                    kind: "review",
+                    type: e.type,
+                    agent: a,
+                    to: author,
+                    text: p.skipped ? `○ review skipped (${oneLine(notes, 60)})` : p.approve === false ? `✎ asks ${author} for changes` : `✓ approves ${author}'s work`,
+                    detail: p.approve === false ? notes : undefined,
+                };
+                add(it);
+                if (!p.skipped) {
+                    talked(a, author);
+                    thread(it);
+                }
+                break;
+            }
+            case "run.merged": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const s = st(a);
+                s.merged++;
+                s.ms += Number(p.ms) || 0;
+                s.tokens += Number(p.tokens) || 0;
+                s.cached += Number(p.cached) || 0;
+                merged++;
+                if (/^Fix: /.test(title(e.task, p)))
+                    s.bugsFixed++; // a QA bug's fix task landed
+                close(a, ts, "ok");
+                add({ ts, kind: "merge", type: e.type, agent: a, text: `✓ merged ${q(title(e.task, p))}`, detail: [pick(p, "reason"), p.ms ? fmtDuration(Number(p.ms)) : "", p.tokens ? fmtTokens(Number(p.tokens)) + " tok" : ""].filter(Boolean).join(" · ") });
+                break;
+            }
+            case "run.failed": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const s = st(a);
+                s.failed++;
+                s.ms += Number(p.ms) || 0;
+                s.tokens += Number(p.tokens) || 0;
+                s.cached += Number(p.cached) || 0;
+                failed++;
+                close(a, ts, "bad");
+                add({ ts, kind: "fail", type: e.type, agent: a, text: `${p.needsYou ? "! needs you:" : "✗ failed"} ${q(title(e.task, p))}`, detail: oneLine(pick(p, "reason"), 300) });
+                break;
+            }
+            case "run.stuck":
+                add({ ts, kind: "fail", type: e.type, agent: null, text: `! blocked by failures: ${list(p.blocked).join(" · ")}` });
+                break;
+            case "run.conflict": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                begin({ agent: a, from: ts, kind: "conflict", label: `resolve ${title(e.task, p)}` });
+                add({ ts, kind: "conflict", type: e.type, agent: a, to: author !== a ? author : null, text: `⇄ resolves a conflict in ${author === a ? "its own" : author + "'s"} ${q(title(e.task, p))} · ${list(p.files).join(", ")} · try ${str(p.attempt)}` });
+                break;
+            }
+            case "run.resolved": {
+                const a = pick(p, "agent") || e.agent || "?";
+                st(a).ms += Number(p.ms) || 0;
+                close(a, ts, p.ok ? "ok" : "bad");
+                add({ ts, kind: "conflict", type: e.type, agent: a, text: `${p.ok ? "✓ resolved" : "✗ resolution rejected"} ${q(title(e.task, p))}`, detail: oneLine(pick(p, "reason"), 200) });
+                break;
+            }
+            // ---- newer phases: design council, takeovers, QA ----
+            case "council.proposal": {
+                const a = pick(p, "agent", "from", "by") || e.agent;
+                st(a).proposals++;
+                add({ ts, kind: "design", type: e.type, agent: a, text: `proposes: ${oneLine(pick(p, "summary", "title", "proposal", "body", "text", "plan"), 300)}`, detail: oneLine(pick(p, "risks", "details", "why"), 300) || undefined });
+                break;
+            }
+            case "council.critique": {
+                const a = pick(p, "agent", "from", "by", "critic") || e.agent;
+                const of = pick(p, "of", "target", "to", "author");
+                st(a).critiques++;
+                const it = { ts, kind: "design", type: e.type, agent: a, to: of || null, text: `critiques ${of ? of + "'s proposal" : "the proposals"}: ${oneLine(pick(p, "body", "critique", "text", "summary", "flaws"), 300)}` };
+                add(it);
+                talked(a, of);
+                thread(it);
+                break;
+            }
+            case "council.plan": {
+                const by = pick(p, "by", "agent", "merged_by") || e.agent;
+                plan.by = plan.by ?? (by ? `${by} (council)` : "council");
+                const tasks = Array.isArray(p.tasks) ? p.tasks : [];
+                councilTasks.push(...tasks);
+                add({ ts, kind: "design", type: e.type, agent: by, text: `settles the plan${tasks.length || p.tasks ? `: ${tasks.length || str(p.tasks)} task(s)` : ""}${pick(p, "summary", "note") ? " · " + oneLine(pick(p, "summary", "note"), 200) : ""}` });
+                break;
+            }
+            case "task.takeover": {
+                const from = pick(p, "from");
+                const to = pick(p, "to") || e.agent;
+                if (e.task && to)
+                    owner.set(e.task, to);
+                talked(from, to);
+                if (pick(p, "kind") === "split") {
+                    add({ ts, kind: "takeover", type: e.type, agent: to, to: from || null, text: `✂ takes part of ${from}'s task: ${q(title(e.task, p))}`, detail: oneLine(pick(p, "reason"), 200) || undefined });
+                    break;
+                }
+                st(from).takeoversOut++;
+                st(to).takeoversIn++;
+                add({ ts, kind: "takeover", type: e.type, agent: to, to: from || null, text: `↻ takes over ${q(title(e.task, p))} from ${from}, on the same branch`, detail: oneLine(pick(p, "reason"), 200) || undefined });
+                break;
+            }
+            case "task.split":
+                add({ ts, kind: "takeover", type: e.type, agent: pick(p, "from") || e.agent, text: `✂ splits ${q(pick(p, "title"))} off ${q(pick(p, "parent_title"))} for a free agent`, detail: list(p.files).join(", ") || undefined });
+                break;
+            case "offer": // the help offer itself is an agent.message in the busy agent's inbox
+                break;
+            case "takeover": {
+                if (roomTakeovers) {
+                    // The first agent's time and tokens on the task it handed over.
+                    const s = st(pick(p, "from"));
+                    s.ms += Number(p.ms) || 0;
+                    s.tokens += Number(p.tokens) || 0;
+                    s.cached += Number(p.cached) || 0;
+                    break;
+                }
+                const from = pick(p, "from", "was", "previous");
+                const to = pick(p, "to", "agent", "by") || e.agent;
+                st(from).takeoversOut++;
+                st(to).takeoversIn++;
+                if (e.task && to)
+                    owner.set(e.task, to);
+                add({ ts, kind: "takeover", type: e.type, agent: to, to: from || null, text: `↻ takes over ${q(title(e.task, p))}${from ? ` from ${from}` : ""}`, detail: oneLine(pick(p, "reason", "why"), 200) || undefined });
+                talked(from, to);
+                break;
+            }
+            case "split": {
+                const from = pick(p, "from", "agent", "by") || e.agent;
+                const parts = Array.isArray(p.into) ? p.into : Array.isArray(p.parts) ? p.parts : Array.isArray(p.tasks) ? p.tasks : [];
+                const names = parts.map((x) => (typeof x === "string" ? x : pick(x ?? {}, "title", "id"))).filter(Boolean);
+                const to = list(p.to ?? p.agents);
+                add({ ts, kind: "takeover", type: e.type, agent: from, text: `✂ splits ${q(title(e.task, p))} into ${names.length || "?"} part(s)${to.length ? " → " + to.join(", ") : ""}`, detail: names.join(" · ") || oneLine(pick(p, "reason"), 200) || undefined });
+                break;
+            }
+            case "council.skipped": {
+                const a = pick(p, "agent") || e.agent;
+                add({ ts, kind: "design", type: e.type, agent: a, text: `${pick(p, "round") || "council"} skipped (${pick(p, "reason") || "no answer"})` });
+                break;
+            }
+            case "qa.done": {
+                const a = e.agent || pick(p, "agent");
+                if (isAgent(a))
+                    close(a, ts, p.ok === false ? "bad" : "ok");
+                add({ ts, kind: "qa", type: e.type, agent: a, text: `${p.ok === false ? "! QA check didn't finish" : "✓ QA check done"} · ${str(p.bugs ?? 0)} bug(s) filed`, detail: p.ms ? fmtDuration(Number(p.ms)) : undefined });
+                break;
+            }
+            case "qa.duplicate":
+                add({ ts, kind: "qa", type: e.type, agent: pick(p, "by") || e.agent, text: `= ${q(pick(p, "title"))} is a duplicate of ${q(title(pick(p, "of")))} · not filed again` });
+                break;
+            case "qa.fixes":
+                add({ ts, kind: "qa", type: e.type, agent: null, text: `QA round ${str(p.round)} fixes: ${str(p.merged ?? 0)} merged, ${str(p.failed ?? 0)} failed` });
+                break;
+            case "qa.capped":
+                add({ ts, kind: "qa", type: e.type, agent: null, text: `! QA stopped after round ${str(p.round)} · the last fixes weren't re-checked${Number(p.open) ? ` · ${str(p.open)} still open` : ""}` });
+                break;
+            case "qa.round": {
+                const a = pick(p, "agent", "by", "checker") || list(p.agents)[0] || e.agent;
+                if (isAgent(a))
+                    begin({ agent: a, from: ts, kind: "qa", label: "QA" });
+                add({ ts, kind: "qa", type: e.type, agent: a, text: `⌕ QA round${p.round !== undefined ? " " + str(p.round) : ""} on the integrated main${list(p.agents).length ? ` · checked by ${list(p.agents).join(", ")} ${qaEyes(list(p.agents), p.authors)}` : ""}`, detail: oneLine(pick(p, "summary", "checks", "note"), 200) || undefined });
+                break;
+            }
+            case "qa.bug": {
+                const a = pick(p, "agent", "by", "found_by", "reporter") || e.agent;
+                st(a).bugsFound++;
+                if (isAgent(a))
+                    close(a, ts, "warn");
+                const owner2 = pick(p, "to", "owner", "assigned_to", "author");
+                add({ ts, kind: "qa", type: e.type, agent: a, to: owner2 || null, text: `🐞 bug: ${oneLine(pick(p, "title", "summary", "bug", "body"), 200)}${owner2 ? ` → ${owner2}` : ""}`, detail: oneLine(pick(p, "details", "repro", "spec", "body"), 300) || undefined });
+                talked(a, owner2);
+                break;
+            }
+            case "qa.unchecked":
+                add({ ts, kind: "qa", type: e.type, agent: null, text: `! QA round ${str(p.round)}: the build was NOT checked · ${str(p.reason) || "no check finished"}` });
+                break;
+            case "qa.clean": {
+                const a = pick(p, "agent", "by") || e.agent;
+                if (isAgent(a))
+                    close(a, ts, "ok");
+                add({ ts, kind: "qa", type: e.type, agent: a, text: `✓ QA${p.round !== undefined ? " round " + str(p.round) : ""} clean${pick(p, "summary", "note") ? " · " + oneLine(pick(p, "summary", "note"), 200) : ""}` });
+                break;
+            }
+            case "qa.fixed":
+            case "qa.fix": {
+                const a = pick(p, "agent", "by", "fixed_by") || e.agent;
+                st(a).bugsFixed++;
+                add({ ts, kind: "qa", type: e.type, agent: a, text: `🔧 fixed: ${oneLine(pick(p, "title", "summary", "bug", "body") || title(e.task), 200)}` });
+                break;
+            }
+            default: {
+                // Unknown (or newer) event: shown with every field, so nothing is lost.
+                const a = pick(p, "agent", "from", "by") || e.agent;
+                const fields = Object.entries(p)
+                    .filter(([k, v]) => v !== null && v !== undefined && v !== "" && k !== "type")
+                    .map(([k, v]) => `${k}=${oneLine(str(v), 80)}`)
+                    .join("  ");
+                const kind = e.type.startsWith("council.") ? "design" : e.type.startsWith("qa.") ? "qa" : e.type.startsWith("takeover") || e.type.startsWith("split") ? "takeover" : "other";
+                if (/^qa\.(fix|fixed)/.test(e.type))
+                    st(a).bugsFixed++;
+                add({ ts, kind, type: e.type, agent: a || null, to: pick(p, "to") || null, text: `[${e.type}]${e.task ? " " + q(title(e.task)) : ""}`, detail: fields || undefined });
+                see(a);
+            }
+        }
+    }
+    for (const a of [...open.keys()])
+        close(a, run.end);
+    // Who proposed what: a council plan's tasks may say whose idea each one was.
+    for (const t of councilTasks) {
+        const pt = plan.tasks.find((x) => x.title === pick(t ?? {}, "title"));
+        const who = list((t ?? {}).proposed_by ?? (t ?? {}).by ?? (t ?? {}).from ?? (t ?? {}).author).join(", ");
+        if (pt && who && !pt.by)
+            pt.by = who;
+    }
+    return { run, runs, agents, plan, design, items, spans, stats, talk, threads, merged, failed };
+}
+// ---- terminal -----------------------------------------------------------------
+const clock = (ms) => {
+    const s = Math.max(0, Math.round(ms / 1000));
+    return `+${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+};
+const kindMark = {
+    design: C.violet,
+    plan: C.violet,
+    task: (s) => s,
+    progress: C.faint,
+    announce: C.faint,
+    message: C.bold,
+    memory: C.violet,
+    handoff: C.violet,
+    review: C.violet,
+    merge: C.green,
+    fail: C.red,
+    conflict: C.yellow,
+    takeover: C.yellow,
+    qa: C.yellow,
+    team: C.faint,
+    other: C.faint,
+};
+export function renderText(s) {
+    const out = [];
+    const r = s.run;
+    const who = (a) => (a ? `${dot(a)} ${C.bold(a)}` : `${C.violet("◆")} ${C.faint("huddle")}`);
+    const line = (it) => {
+        const head = it.to && it.kind === "message" ? `${who(it.agent)} ${C.faint("→")} ${who(it.to)}${C.faint(":")}` : who(it.agent);
+        const tag = it.kind === "message" && it.detail ? C.faint(` (${it.detail})`) : "";
+        out.push(`  ${C.faint(pad(clock(it.ts - r.start), 7))} ${head} ${kindMark[it.kind](it.text)}${tag}`);
+        if (it.detail && it.kind !== "message")
+            for (const l of it.detail.split("\n").slice(0, 6))
+                out.push(C.faint(`            ${l}`));
+    };
+    out.push(`${C.violet("STORY")} ${C.bold(JSON.stringify(goalTitle(r.goal)))}`);
+    out.push(C.faint(`  run ${r.index} of ${s.runs}${r.id ? " · " + r.id : ""} · ${new Date(r.start).toLocaleString()} · ${fmtDuration(r.end - r.start)} · ${s.merged} merged, ${s.failed} failed`));
+    if (s.agents.length)
+        out.push(`  ${C.faint("crew:")} ${s.agents.map((a) => `${dot(a)} ${a}`).join("  ")}`);
+    if (s.design.length) {
+        out.push("", C.violet("DESIGN COUNCIL"));
+        s.design.forEach(line);
+    }
+    if (s.plan.tasks.length) {
+        out.push("", `${C.violet("PLAN")}${s.plan.by ? C.faint(" · by " + s.plan.by) : ""}${s.plan.note ? C.faint(" · " + s.plan.note) : ""} ${C.faint(`(${s.plan.tasks.length} task${s.plan.tasks.length > 1 ? "s" : ""})`)}`);
+        const num = new Map(s.plan.tasks.map((t, i) => [t.id, i + 1]));
+        s.plan.tasks.forEach((t, i) => {
+            const deps = t.deps.map((d) => "#" + (num.get(d) ?? d));
+            out.push(`  ${C.faint(String(i + 1).padStart(2) + ".")} ${t.title}` +
+                C.faint([deps.length ? `after ${deps.join(", ")}` : "", t.prefers.length ? `suits ${t.prefers.join("/")}` : "", t.files.length ? t.files.slice(0, 4).join(", ") : "", t.by ? `proposed by ${t.by}` : ""]
+                    .filter(Boolean)
+                    .map((x) => " · " + x)
+                    .join("")));
+        });
+    }
+    out.push("", C.violet("TIMELINE"));
+    if (!s.items.length)
+        out.push(C.faint("  (nothing happened in this run)"));
+    s.items.forEach(line);
+    if (s.agents.length) {
+        out.push("", C.violet("WHO DID WHAT"));
+        const cols = ["merged", "failed", "reviews", "msgs out/in", "design", "bugs found/fixed", "takeovers in/out", "tool calls", "time", "tokens"];
+        const w = Math.max(10, ...s.agents.map((a) => a.length + 4)); // "● name" + a gap
+        out.push(C.faint("  " + pad("", w) + cols.map((c) => pad(c, Math.max(c.length, 6) + 2)).join("")));
+        for (const a of s.agents) {
+            const x = s.stats.get(a);
+            const vals = [
+                x.merged,
+                x.failed,
+                x.reviews + (x.changesAsked ? ` (${x.changesAsked}✎)` : ""),
+                `${x.sent}/${x.received}`,
+                x.proposals || x.critiques ? `${x.proposals}p ${x.critiques}c` : "0",
+                `${x.bugsFound}/${x.bugsFixed}`,
+                `${x.takeoversIn}/${x.takeoversOut}`,
+                x.toolCalls,
+                x.ms ? fmtDuration(x.ms) : "—",
+                x.tokens ? fmtTokens(x.tokens) : "—",
+            ].map(String);
+            out.push(`  ${pad(`${dot(a)} ${a}`, w)}${vals.map((v, i) => pad(v, Math.max(cols[i].length, 6) + 2)).join("")}`);
+        }
+        out.push("", `${C.violet("WHO TALKED TO WHOM")} ${C.faint("(row → column: messages, questions, answers, reviews, critiques, handoffs)")}`);
+        const cw = Math.max(8, ...s.agents.map((a) => a.length + 2));
+        out.push("  " + pad("", w) + s.agents.map((a) => pad(a, cw)).join(""));
+        for (const a of s.agents) {
+            const row = s.talk.get(a);
+            out.push(`  ${pad(`${dot(a)} ${a}`, w)}${s.agents.map((b) => pad(a === b ? C.faint("·") : row?.get(b) ? C.bold(String(row.get(b))) : C.faint("0"), cw)).join("")}`);
+        }
+    }
+    return out.join("\n");
+}
+export function renderRunList(runs) {
+    if (!runs.length)
+        return C.faint("  no runs yet — type a goal to start.");
+    return runs
+        .map((r) => {
+        const merged = r.events.filter((e) => e.type === "run.merged").length;
+        const failed = r.events.filter((e) => e.type === "run.failed").length;
+        return `  ${C.bold(String(r.index).padStart(3))}  ${C.faint(new Date(r.start).toLocaleString())}  ${pad(fmtDuration(r.end - r.start), 7)} ${JSON.stringify(goalTitle(r.goal, 100))} ${C.faint(`· ${merged} merged${failed ? `, ${failed} failed` : ""}${r.id ? " · " + r.id : ""}`)}`;
+    })
+        .join("\n");
+}
+// ---- HTML (a static, self-contained report file) --------------------------------
+const esc = (s) => str(s).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+const colorOf = (a) => (a ? AGENT_COLOR[a.split("#")[0]] ?? "#8A857C" : "#7B6CF6");
+export function renderHtml(s) {
+    const r = s.run;
+    const span = Math.max(1, r.end - r.start);
+    const pct = (ts) => (((ts - r.start) / span) * 100).toFixed(3);
+    const chip = (a) => `<span class="who"><i style="background:${colorOf(a)}"></i>${esc(a ?? "huddle")}</span>`;
+    // Lanes: one per agent; spans are its tasks/reviews/conflicts/QA; dots are its messages.
+    const ticks = Array.from({ length: 5 }, (_, i) => `<span style="left:${i * 25}%">${esc(clock((span * i) / 4))}</span>`).join("");
+    const lanes = s.agents
+        .map((a) => {
+        const bars = s.spans
+            .filter((x) => x.agent === a)
+            .map((x) => `<div class="bar ${x.kind} ${x.outcome ?? ""}" style="left:${pct(x.from)}%;width:max(4px,${(((x.to - x.from) / span) * 100).toFixed(3)}%);--c:${colorOf(a)}" title="${esc(`${x.kind}: ${x.label} · ${clock(x.from - r.start)}–${clock(x.to - r.start)}`)}"><span>${esc(x.label)}</span></div>`)
+            .join("");
+        const marks = [...s.items, ...s.design]
+            .filter((it) => it.agent === a && ["message", "design", "qa", "takeover", "merge", "fail", "announce"].includes(it.kind))
+            .map((it) => `<b class="mark ${it.kind}" style="left:${pct(it.ts)}%" title="${esc(`${clock(it.ts - r.start)} ${it.to ? "→ " + it.to + ": " : ""}${it.text}`)}"></b>`)
+            .join("");
+        return `<div class="lane" data-lane="${esc(a)}"><div class="name">${chip(a)}</div><div class="track">${bars}${marks}</div></div>`;
+    })
+        .join("");
+    const row = (it) => `<li class="${it.kind}"><time>${esc(clock(it.ts - r.start))}</time><div>${chip(it.agent)}${it.to ? ` <span class="arrow">→</span> ${chip(it.to)}` : ""} <span class="text">${esc(it.text)}</span>${it.detail ? `<div class="detail">${esc(it.detail)}</div>` : ""}</div></li>`;
+    const num = new Map(s.plan.tasks.map((t, i) => [t.id, i + 1]));
+    const plan = s.plan.tasks
+        .map((t) => `<li><b>${esc(t.title)}</b>${t.deps.length ? ` <small>after ${esc(t.deps.map((d) => "#" + (num.get(d) ?? d)).join(", "))}</small>` : ""}${t.prefers.length ? ` <small>suits ${esc(t.prefers.join("/"))}</small>` : ""}${t.by ? ` <small>proposed by ${esc(t.by)}</small>` : ""}${t.files.length ? `<div class="detail">${esc(t.files.join(", "))}</div>` : ""}</li>`)
+        .join("");
+    const threads = [...s.threads.entries()]
+        .map(([pair, msgs]) => `<details open><summary>${esc(pair)} <small>${msgs.length} message${msgs.length > 1 ? "s" : ""}</small></summary><ol class="thread">${msgs
+        .map((m) => `<li class="${m.agent === pair.split(" ↔ ")[0] ? "l" : "r"}" style="--c:${colorOf(m.agent)}"><div class="meta">${esc(m.agent)} → ${esc(m.to)} · ${esc(clock(m.ts - r.start))}${m.detail && m.kind === "message" ? " · " + esc(m.detail) : ""}</div>${esc(m.text)}${m.detail && m.kind !== "message" ? `<div class="detail">${esc(m.detail)}</div>` : ""}</li>`)
+        .join("")}</ol></details>`)
+        .join("");
+    const statRows = s.agents
+        .map((a) => {
+        const x = s.stats.get(a);
+        return `<tr><th>${chip(a)}</th><td>${x.merged}</td><td>${x.failed}</td><td>${x.reviews}${x.changesAsked ? ` (${x.changesAsked}✎)` : ""}</td><td>${x.sent}/${x.received}</td><td>${x.proposals}/${x.critiques}</td><td>${x.bugsFound}/${x.bugsFixed}</td><td>${x.takeoversIn}/${x.takeoversOut}</td><td>${x.toolCalls}</td><td>${x.ms ? esc(fmtDuration(x.ms)) : "—"}</td><td>${x.tokens ? esc(fmtTokens(x.tokens)) : "—"}</td></tr>`;
+    })
+        .join("");
+    const matrix = `<tr><th></th>${s.agents.map((a) => `<th>${esc(a)}</th>`).join("")}</tr>${s.agents
+        .map((a) => `<tr><th>${chip(a)}</th>${s.agents.map((b) => (a === b ? `<td class="self">·</td>` : `<td class="${s.talk.get(a)?.get(b) ? "hot" : ""}">${s.talk.get(a)?.get(b) ?? 0}</td>`)).join("")}</tr>`)
+        .join("")}`;
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Huddle story</title>
+<style>
+:root{--bg:#faf9f6;--fg:#1d1b18;--mute:#77716a;--line:#e4e0d8;--card:#fff;--ok:#2e9e5b;--bad:#d14b3c;--warn:#c58a12;--brand:#7B6CF6}
+@media (prefers-color-scheme: dark){:root:not([data-theme="light"]){--bg:#15141a;--fg:#ece9e3;--mute:#9a948b;--line:#2c2a33;--card:#1d1c23}}
+:root[data-theme="dark"]{--bg:#15141a;--fg:#ece9e3;--mute:#9a948b;--line:#2c2a33;--card:#1d1c23}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.5 ui-sans-serif,system-ui,-apple-system,"Segoe UI",sans-serif}
+main{max-width:1100px;margin:0 auto;padding:20px 16px 60px}
+h1{font-size:22px;margin:0 0 4px}h2{font-size:15px;text-transform:uppercase;letter-spacing:.06em;color:var(--brand);margin:32px 0 10px}
+.sub,small,.detail,time,.meta{color:var(--mute)}small{font-size:12px;margin-left:6px}
+.who{display:inline-flex;align-items:center;gap:5px;font-weight:600;white-space:nowrap}.who i{width:9px;height:9px;border-radius:50%;display:inline-block}
+.scroll{overflow-x:auto;-webkit-overflow-scrolling:touch;border:1px solid var(--line);border-radius:10px;background:var(--card)}
+.lanes{min-width:640px;padding:8px 12px 12px}
+.axis{position:relative;height:18px;margin-left:120px;font-size:11px;color:var(--mute)}.axis span{position:absolute;transform:translateX(-50%)}.axis span:first-child{transform:none}.axis span:last-child{transform:translateX(-100%)}
+.lane{display:flex;align-items:center;height:38px;border-top:1px solid var(--line)}
+.lane .name{width:120px;flex:none;overflow:hidden;text-overflow:ellipsis;font-size:13px}
+.track{position:relative;flex:1;height:26px}
+.bar{position:absolute;top:3px;height:20px;border-radius:5px;background:color-mix(in srgb,var(--c) 30%,transparent);border:1px solid var(--c);overflow:hidden;font-size:11px;line-height:18px;padding:0 4px;white-space:nowrap}
+.bar span{opacity:.9}.bar.review{border-style:dashed}.bar.conflict{border-color:var(--warn)}.bar.qa{border-style:dotted}
+.bar.ok{box-shadow:inset -3px 0 0 var(--ok)}.bar.bad{box-shadow:inset -3px 0 0 var(--bad)}.bar.warn{box-shadow:inset -3px 0 0 var(--warn)}
+.mark{position:absolute;top:-3px;width:7px;height:7px;margin-left:-3px;border-radius:50%;background:var(--brand)}
+.mark.merge{background:var(--ok)}.mark.fail{background:var(--bad)}.mark.qa,.mark.takeover{background:var(--warn)}.mark.announce{background:var(--mute)}
+ol,ul{padding:0;margin:0;list-style:none}
+.timeline li{display:flex;gap:10px;padding:7px 0;border-top:1px solid var(--line)}
+.timeline time{flex:none;width:48px;font-variant-numeric:tabular-nums;font-size:13px}
+.timeline .merge .text{color:var(--ok)}.timeline .fail .text{color:var(--bad)}.timeline .conflict .text,.timeline .qa .text,.timeline .takeover .text{color:var(--warn)}
+.timeline .progress .text,.timeline .announce .text,.timeline .team .text,.timeline .other .text{color:var(--mute)}
+.arrow{color:var(--mute)}.detail{font-size:13px;white-space:pre-wrap;word-break:break-word}
+.plan li{padding:6px 0;border-top:1px solid var(--line)}.plan{counter-reset:n}.plan li::before{counter-increment:n;content:counter(n) ". ";color:var(--mute)}
+details{border:1px solid var(--line);border-radius:10px;background:var(--card);margin:10px 0;padding:8px 12px}summary{cursor:pointer;font-weight:600}
+.thread{display:flex;flex-direction:column;gap:8px;margin-top:10px}
+.thread li{max-width:85%;padding:8px 10px;border-radius:12px;border:1px solid var(--line);border-left:4px solid var(--c);word-break:break-word}
+.thread li.r{align-self:flex-end;border-left:1px solid var(--line);border-right:4px solid var(--c)}.thread .meta{font-size:12px}
+table{border-collapse:collapse;width:100%;font-size:13px;font-variant-numeric:tabular-nums}th,td{padding:6px 8px;border-bottom:1px solid var(--line);text-align:left;white-space:nowrap}
+td.hot{font-weight:700;color:var(--brand)}td.self{color:var(--mute)}
+</style>
+</head>
+<body>
+<main>
+<h1>${esc(goalTitle(r.goal))}</h1>${goalTitle(r.goal) !== r.goal.trim() ? `<details><summary>The goal</summary><pre style="white-space:pre-wrap">${esc(r.goal)}</pre></details>` : ""}
+<div class="sub">run ${r.index} of ${s.runs}${r.id ? " · " + esc(r.id) : ""} · ${esc(new Date(r.start).toLocaleString())} · ${esc(fmtDuration(r.end - r.start))} · ${s.merged} merged, ${s.failed} failed · ${s.agents.length} agent${s.agents.length === 1 ? "" : "s"}</div>
+
+<h2>Who was doing what, when</h2>
+<div class="scroll"><div class="lanes"><div class="axis">${ticks}</div>${lanes || '<p class="sub">no agents in this run</p>'}</div></div>
+<p class="sub"><small>bars: tasks (solid) · reviews (dashed) · conflict resolutions · QA (dotted); right edge green = merged/approved, red = failed/changes, amber = skipped/bug. Dots: messages, design, QA, merges.</small></p>
+${s.design.length ? `<h2>Design council</h2><ol class="timeline">${s.design.map(row).join("")}</ol>` : ""}
+${s.plan.tasks.length ? `<h2>Plan${s.plan.by ? ` <small>by ${esc(s.plan.by)}</small>` : ""}</h2><ol class="plan">${plan}</ol>` : ""}
+<h2>Conversations</h2>
+${threads || '<p class="sub">no agent-to-agent messages in this run</p>'}
+<h2>Who did what</h2>
+<div class="scroll"><table><tr><th>agent</th><th>merged</th><th>failed</th><th>reviews</th><th>msgs out/in</th><th>proposals/critiques</th><th>bugs found/fixed</th><th>takeovers in/out</th><th>tool calls</th><th>time</th><th>tokens</th></tr>${statRows}</table></div>
+<h2>Who talked to whom <small>row → column</small></h2>
+<div class="scroll"><table>${matrix}</table></div>
+<h2>Timeline</h2>
+<ol class="timeline">${s.items.map(row).join("") || '<li class="sub">nothing happened in this run</li>'}</ol>
+</main>
+</body>
+</html>
+`;
+}
+// ---- CLI ------------------------------------------------------------------------
+/** `huddle story [--list] [--run <n|id>] [--html <file>]` against this repo's room. */
+export async function runStory(args) {
+    const { dbPath } = await import("./app.js");
+    const flag = (name) => {
+        const i = args.indexOf(name);
+        if (i >= 0)
+            return args[i + 1];
+        return args.find((a) => a.startsWith(name + "="))?.slice(name.length + 1);
+    };
+    if (!fs.existsSync(dbPath())) {
+        console.log(C.faint("  no runs yet — this repo has no room (.huddle/huddle.db). Type a goal in `huddle` to start."));
+        return;
+    }
+    const { RoomDB } = await import("../room/db.js");
+    const db = new RoomDB(dbPath());
+    let runs;
+    try {
+        runs = splitRuns(db.allEvents());
+    }
+    finally {
+        db.close();
+    }
+    if (args.includes("--list"))
+        return void console.log(renderRunList(runs));
+    const which = flag("--run") ?? args.find((a) => /^-?\d+$/.test(a));
+    const run = pickRun(runs, which);
+    if (!run) {
+        console.log(runs.length ? C.red(`✗ no run ${which}.`) + " See `huddle story --list`." : C.faint("  no runs yet — type a goal to start."));
+        if (runs.length)
+            process.exitCode = 1;
+        return;
+    }
+    const story = buildStory(run, runs.length);
+    const html = flag("--html");
+    if (args.includes("--html") && !html) {
+        console.log(C.red("✗ --html needs a file:") + " huddle story --html story.html");
+        process.exitCode = 1;
+        return;
+    }
+    if (html) {
+        const out = path.resolve(html);
+        fs.mkdirSync(path.dirname(out), { recursive: true });
+        fs.writeFileSync(out, renderHtml(story));
+        console.log(`${C.green("✓")} wrote ${out} ${C.faint(`· one file, no network · ${story.agents.length} lanes, ${story.items.length} events`)}`);
+        return;
+    }
+    console.log(renderText(story));
+}
+//# sourceMappingURL=story.js.map