huddle-cli 0.1.0 → 0.1.3

package/dist/ui/export.js

@@ -0,0 +1,1194 @@
+// `huddle runs` and `huddle export` — a run's history the way chat apps keep
+// one: the summary, the conversation, and each agent's own session.
+//
+//   huddle runs                               every run in this repo: when, goal, agents, result, cost
+//   huddle export [<run>|latest]              the latest run as a chat (Markdown)
+//     --level summary|chat|full               summary: result, who did what, decisions, teamwork, cost
+//                                             chat: + every message in time order, in full (default)
+//                                             full: + each agent's session per task (said / ran / wrote)
+//     --format md|html|json                   (default md; or from --out's extension)
+//     --out <path>                            a file, a folder, or - for stdout
+//                                             (default <repo>/.huddle/exports/run-<n>-<slug>.<ext>)
+//     --no-redact                             keep likely secrets (redacted by default)
+//
+// Everything comes from what `huddle story` reads (src/ui/story.ts: splitRuns,
+// buildStory and its summaries) plus the agents' logs (src/ui/transcript.ts).
+// The story shortens lines for a timeline; the export keeps every word.
+//
+// exportRun(db, run, {level, format}) is the one entry point for other callers
+// (the hand-off brief, a dashboard): it returns the document as a string.
+//
+// ---- The JSON schema (format "json"), version 1 ------------------------------------
+// Stable: fields are only ever added. Times are ms since the epoch; `t` is
+// "+m:ss" from the run's start. Every list is present at every level (empty
+// when the level leaves it out).
+//
+//   {
+//     schema: "huddle.export", version: 1, level: "summary"|"chat"|"full",
+//     generated: ISO time, redacted: <secrets replaced; 0 when --no-redact>,
+//     run:    { index, of, id, goal, title, start, end, ms },
+//     agents: [{ id, color, merged, failed, reviews, qa, sent, received, proposals,
+//                critiques, bugsFound, bugsFixed, takeoversIn, takeoversOut,
+//                toolCalls, ms, tokens, cached }],
+//     summary: {
+//       result:    { merged, failed, merges, green, qaRounds, qa: {text, tone}|null, tokens, cached, ms },
+//       plan:      { by, tasks: [{ id, title, deps, files, prefers, idea, doneBy, status }] },
+//       decisions: [{ risk, by, body }],
+//       contract:  { by, text, amendments: [{ by, version, change }] } | null,
+//       teamwork:  { tally: [{ n, label }], lines: [{ label, text }] },
+//       cost:      [{ agent, tokens, cached, ms }]
+//     },
+//     messages: [{ i, ts, t, phase: "goal"|"council"|"plan"|"build"|"qa",
+//                  kind, from, to: [], label, text, task?: {id, title}, replyTo? }],
+//     transcripts: { "<agent>-<task>": { agent, task, title, spec, file, found,
+//                    format: "claude"|"codex"|"cursor"|"raw", bytes,
+//                    turns: [{ kind: "prompt"|"text"|"thinking"|"tool"|"note"|"end",
+//                              text, tool?, input?, output?, error?, ts? }] } }
+//   }
+import fs from "node:fs";
+import path from "node:path";
+import { redactSecrets } from "../room/context.js";
+import { fmtDuration, fmtTokens } from "../adapters/usage.js";
+import { C, dot } from "./term.js";
+import { STORY_CSS, agreement, buildStory, buddyNotes, clock, collabLines, colorOf, crewRows, esc, goalTitle, list, oneLine, outcome, phases, pick, pickRun, plural, splitRuns, str, tally, } from "./story.js";
+import { readLog } from "./transcript.js";
+export const EXPORT_LEVELS = ["summary", "chat", "full"];
+export const EXPORT_FORMATS = ["md", "html", "json"];
+export const EXPORT_SCHEMA_VERSION = 1;
+/**
+ * A run's name: the goal's first sentence (a brief's first line can be a
+ * paragraph). Capped; the whole goal is always in the document too.
+ */
+export function headline(goal, n = 100) {
+    const first = goal.trim().split(/\n/)[0] ?? "";
+    const sentence = /^(.{8,}?[.!?])(?:\s|$)/.exec(first)?.[1] ?? first;
+    return goalTitle(sentence, n);
+}
+/** Task text in the chat: a QA brief carries the whole goal and diff, so long ones are cut (the full export has them whole). */
+const SPEC_IN_CHAT = 800;
+// ---- the chat --------------------------------------------------------------------
+const NOT_AGENTS = new Set(["huddle", "room", "all", "you", "council", "", "?"]);
+/** The run's conversation, in time order, every message whole. */
+export function chatOf(run, story) {
+    const out = [];
+    const phaseOf = new Map();
+    const titles = new Map();
+    const owner = new Map();
+    for (const e of run.events) {
+        if (e.type === "task.added")
+            titles.set(pick(e.p, "id") || e.task || "", pick(e.p, "title"));
+        else if (pick(e.p, "title") && e.task && !titles.has(e.task))
+            titles.set(e.task, pick(e.p, "title"));
+    }
+    const crew = story.agents;
+    const title = (task, p) => pick(p ?? {}, "title") || (task ? titles.get(task) ?? task : "");
+    const taskRef = (task, p) => (task ? { task: { id: task, title: title(task, p) } } : {});
+    const q = (s) => (s ? `“${s}”` : "");
+    const firstWork = run.events.find((e) => e.type === "run.start" || e.type === "task.claimed")?.ts ?? Infinity;
+    const hasRun = run.events.some((e) => e.type.startsWith("run."));
+    const roomTakeovers = run.events.some((e) => e.type === "task.takeover");
+    const viaScheduler = (e) => run.events.some((x) => x.type === "run.start" && x.task === e.task && x.agent === e.agent && Math.abs(x.ts - e.ts) < 3000);
+    // Notes Huddle delivered (buddy notes, radar findings): their message ids, so a reply can say what it answers.
+    const noteBy = new Map();
+    const noteAuthor = new Map();
+    const msgBy = new Map();
+    const recent = [];
+    let planned = false;
+    let lastMsg = null;
+    // Phases by the order events were written, not their clocks (a fast machine writes many in one ms).
+    let working = false;
+    let checking = false;
+    const push = (m, phase) => {
+        out.push(m);
+        phaseOf.set(m, phase ?? (checking ? "qa" : working ? "build" : /^(proposal|critique|adopt|flaw|ratify|contract)$/.test(m.kind) ? "council" : "plan"));
+        lastMsg = m;
+        return m;
+    };
+    const sys = (ts, label, text = "", extra = {}) => push({ ts, kind: "system", from: "huddle", to: [], label, text, ...extra });
+    const plan = (ts) => {
+        if (planned || !story.plan.tasks.length)
+            return;
+        planned = true;
+        const num = new Map(story.plan.tasks.map((t, i) => [t.id, i + 1]));
+        const text = story.plan.tasks
+            .map((t, i) => {
+            const bits = [t.deps.length ? `after ${t.deps.map((d) => "#" + (num.get(d) ?? d)).join(", ")}` : "", t.prefers.length ? `suits ${t.prefers.join("/")}` : "", t.files.length ? t.files.join(", ") : "", t.by ? `idea from ${t.by}` : ""].filter(Boolean);
+            return `${i + 1}. ${t.title}${bits.length ? ` — ${bits.join(" · ")}` : ""}`;
+        })
+            .join("\n");
+        // "council (claude, codex, cursor) → claude": the council designed it, claude wrote it down.
+        const by = story.plan.by || "huddle";
+        const writer = /→\s*(\S+)\s*$/.exec(by)?.[1] ?? by;
+        push({ ts, kind: "plan", from: writer, to: crew.length ? ["all"] : [], label: `the plan: ${plural(story.plan.tasks.length, "task")}${writer !== by ? ` (by ${by})` : ""}`, text }, "plan");
+    };
+    for (const e of run.events) {
+        const p = e.p;
+        const ts = e.ts;
+        if (!planned && ts >= firstWork && (e.type === "run.start" || e.type === "task.claimed"))
+            plan(ts);
+        if (e.type === "run.start" || e.type === "task.claimed")
+            working = true;
+        if (e.type === "qa.round")
+            checking = true;
+        if (/^(council\.|takeover|split|task\.takeover|task\.split|qa\.)/.test(e.type)) {
+            const sig = [e.type, e.task, pick(p, "from", "agent", "by") || e.agent, pick(p, "to"), oneLine(pick(p, "title", "summary", "body", "reason", "text"), 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":
+                if (pick(p, "goal"))
+                    push({ ts, kind: "goal", from: "you", to: crew.length ? crew : ["all"], label: "the goal", text: pick(p, "goal") }, "goal");
+                break;
+            case "board.cleared":
+            case "agent.status":
+            case "agent.joined":
+            case "handoff.ready":
+            case "run.tokens":
+            case "run.handoff":
+            case "run.contract":
+            case "plug.call":
+            case "context.search":
+            case "context.read":
+            case "context.removed":
+            case "offer":
+            case "radar.finding":
+            case "radar.stats":
+            case "followup":
+            case "note.open":
+            case "buddy.start":
+            case "buddy.end":
+                break;
+            case "plan.made":
+                plan(ts);
+                break;
+            case "task.added": {
+                if (ts <= firstWork)
+                    break; // in the plan
+                const by = pick(p, "proposed_by", "by", "author", "filed_by");
+                const spec = pick(p, "spec");
+                const cut = spec.length > SPEC_IN_CHAT ? spec.slice(0, SPEC_IN_CHAT).replace(/\s+\S*$/, "") + `\n… (${(spec.length - SPEC_IN_CHAT).toLocaleString("en-US")} more characters: the whole task is under Sessions in --level full)` : spec;
+                push({ ts, kind: "system", from: by && !NOT_AGENTS.has(by) ? by : "huddle", to: [], label: `new task on the board: ${q(pick(p, "title"))}`, text: cut, ...taskRef(pick(p, "id") || e.task, p) });
+                break;
+            }
+            case "task.claimed":
+                if (e.task && e.agent)
+                    owner.set(e.task, e.agent);
+                if (!viaScheduler(e))
+                    sys(ts, `${e.agent ?? "?"} claims ${q(title(e.task))}`, "", taskRef(e.task));
+                break;
+            case "task.status": {
+                if (hasRun)
+                    break;
+                const s = pick(p, "status");
+                if (["merged", "failed", "needs_you"].includes(s))
+                    push({ ts, kind: s === "merged" ? "merge" : "fail", from: "huddle", to: [], label: `${s === "merged" ? "✓ merged" : s === "failed" ? "✗ failed" : "! needs you:"} ${q(title(e.task))}${e.task && owner.get(e.task) ? ` (${owner.get(e.task)})` : ""}`, text: "", ...taskRef(e.task) });
+                break;
+            }
+            case "task.progress": {
+                const note = pick(p, "note");
+                if (!note)
+                    break;
+                push({ ts, kind: "progress", from: (e.task && owner.get(e.task)) || e.agent || "?", to: ["room"], label: `${str(p.pct ?? "?")}% on ${q(title(e.task))}`, text: note, ...taskRef(e.task) });
+                break;
+            }
+            case "plan.announced": {
+                const touches = list(p.touches);
+                const hits = Array.isArray(p.conflicts) ? p.conflicts : [];
+                const text = [pick(p, "intent"), touches.length ? `touches: ${touches.join(", ")}` : "", hits.length ? `overlaps: ${hits.map((h) => `${str(h.path)} (held by ${str(h.held_by)})`).join(", ")}` : ""].filter(Boolean).join("\n");
+                push({ ts, kind: "announce", from: e.agent ?? "?", to: ["room"], label: `announces its plan for ${q(title(e.task))}`, text, ...taskRef(e.task) });
+                break;
+            }
+            // An agent's question for the person at the keyboard (huddle_ask_user), and what came back.
+            case "user.ask": {
+                const opts = list(p.options);
+                push({
+                    ts,
+                    kind: "question",
+                    from: pick(p, "from") || e.agent || "?",
+                    to: ["you"],
+                    label: "asks you",
+                    text: [pick(p, "question"), pick(p, "why"), ...opts.map((o, i) => `${i + 1}. ${o}${i === 0 ? " (recommended)" : ""}`)].filter(Boolean).join("\n"),
+                });
+                break;
+            }
+            case "user.answer": {
+                const mine = pick(p, "by") === "you";
+                push({ ts, kind: "answer", from: mine ? "you" : "huddle", to: [pick(p, "from") || e.agent || "?"], label: mine ? "answers" : "no answer in time — goes with option 1", text: pick(p, "answer") });
+                break;
+            }
+            case "memory.added": {
+                const author = pick(p, "author") || e.agent || "";
+                const body = pick(p, "body");
+                const why = pick(p, "why");
+                // Your own words: already in the chat as the message or the answer they were.
+                if (author === "you")
+                    break;
+                if (author === "huddle") {
+                    if (/red test gate/.test(body))
+                        push({ ts, kind: "fail", from: "huddle", to: [], label: "the test gate is red", text: body });
+                    break;
+                }
+                if (/^Review of /.test(body))
+                    break; // the review's own message says it
+                // Huddle's copies in an agent's name: a late buddy note, a reply ("claude → codex: …") — the chat has them already.
+                if (/^Buddy note on “|^Buddy note on "/.test(body) || /^\S+ → \S+: /.test(body))
+                    break;
+                const done = /^Task (\S+) done:\s*/.exec(body);
+                if (done) {
+                    push({ ts, kind: "done", from: author, to: ["room"], label: `done: ${q(title(done[1]))}`, text: body.slice(done[0].length), ...taskRef(done[1]) });
+                    break;
+                }
+                if (author === "council") {
+                    const risk = /risk/i.test(pick(p, "kind")) || /^council risk:/.test(body);
+                    push({ ts, kind: "decision", from: "council", to: ["all"], label: risk ? `risk${/flagged by (\S+)/.exec(why)?.[1] ? " flagged by " + /flagged by (\S+)/.exec(why)[1] : ""}` : "decided", text: body.replace(/^council( risk)?:\s*/, "") }, working ? undefined : "plan");
+                    break;
+                }
+                push({ ts, kind: "memory", from: author, to: ["shared memory"], label: `remembers (${pick(p, "kind") || "note"})`, text: [body, why ? `why: ${why}` : ""].filter(Boolean).join("\n") });
+                break;
+            }
+            case "agent.message":
+            case "note": {
+                const from = pick(p, "from") || e.agent || "?";
+                const to = pick(p, "to") || "?";
+                const body = pick(p, "body");
+                const kind = pick(p, "kind") || "note";
+                const id = pick(p, "id");
+                // Huddle's delivery of a buddy note / radar finding: the checkpoint and radar items carry them, once.
+                const buddy = /^buddy check from (\S+?)(?: at \d+%)?:/.exec(body);
+                if (from === "huddle" && buddy) {
+                    if (id)
+                        noteBy.set(id, `${buddy[1]}'s buddy note`);
+                    if (id)
+                        noteAuthor.set(id, buddy[1]);
+                    break;
+                }
+                if (from === "huddle" && /^Huddle radar:/.test(body)) {
+                    if (id)
+                        noteBy.set(id, "the radar's finding");
+                    break;
+                }
+                if (/^contract v\d+ by /.test(body))
+                    break; // contract.amended says it
+                if (from === "huddle" && / is taking “.*” \(files .*\) in \d+s unless you reply/.test(body)) {
+                    push({ ts, kind: "system", from: "huddle", to: [to], label: "proposes a pair", text: body, ...taskRef(e.task) });
+                    if (id)
+                        noteBy.set(id, "Huddle's pairing offer");
+                    break;
+                }
+                if (from === "huddle" && /is free and can take part of your task|huddle_split/.test(body)) {
+                    push({ ts, kind: "system", from: "huddle", to: [to], label: "offers help", text: body, ...taskRef(e.task) });
+                    break;
+                }
+                const replyTo = pick(p, "reply_to");
+                const re = replyTo ? noteBy.get(replyTo) ?? msgBy.get(replyTo) : undefined;
+                // One message to "all" is written once per teammate: show it once, to all of them.
+                const prev = lastMsg;
+                if (prev && prev.from === from && prev.text === body && prev.kind !== "system" && Math.abs(prev.ts - ts) < 1500 && (prev.kind === "message" || prev.kind === "question" || prev.kind === "answer")) {
+                    if (!prev.to.includes(to))
+                        prev.to.push(to);
+                    if (id)
+                        msgBy.set(id, `${from}'s message`);
+                    break;
+                }
+                const k = kind === "question" ? "question" : kind === "answer" ? "answer" : "message";
+                // A reply to a buddy note goes back through Huddle to the teammate who wrote it.
+                const back = to === "huddle" && replyTo ? noteAuthor.get(replyTo) : undefined;
+                push({ ts, kind: k, from, to: [back ?? to], label: k === "question" ? "asks" : k === "answer" ? "answers" : replyTo ? "replies" : "says", text: body, ...taskRef(e.task), ...(re ? { replyTo: re } : replyTo ? { replyTo: "an earlier message" } : {}) });
+                if (id)
+                    msgBy.set(id, `${from}'s ${k === "question" ? "question" : "message"}`);
+                break;
+            }
+            case "ask":
+                if (p.routed)
+                    break;
+                push({ ts, kind: "question", from: pick(p, "from") || e.agent || "?", to: [pick(p, "to") || "room"], label: "asks", text: pick(p, "question"), ...taskRef(e.task) });
+                break;
+            case "answer":
+                if (pick(p, "source") === "teammate")
+                    break;
+                push({ ts, kind: "answer", from: pick(p, "from") || "room", to: pick(p, "to") ? [pick(p, "to")] : [], label: `answers (from ${pick(p, "source") || "shared memory"})`, text: pick(p, "answer") });
+                break;
+            case "handoff": {
+                const from = pick(p, "from") || e.agent || "?";
+                const to = pick(p, "to");
+                const files = list(p.files);
+                const syms = list(p.symbols);
+                // One handoff, written once per teammate who builds on it.
+                const prev = [...out].reverse().find((m) => m.kind === "handoff" && m.from === from && m.task?.id === pick(p, "task") && ts - m.ts < 5000);
+                if (prev) {
+                    if (to && to !== from && !prev.to.includes(to))
+                        prev.to.push(to);
+                    break;
+                }
+                push({ ts, kind: "handoff", ...(pick(p, "task") ? { task: { id: pick(p, "task"), title: pick(p, "title") } } : {}), from, to: to && to !== from ? [to] : [], label: `hands off ${q(pick(p, "title"))}${to && to !== from ? "" : " to whoever builds on it"}`, text: [files.length ? `files: ${files.join(", ")}` : "", ...syms.map((s) => `· ${s}`)].filter(Boolean).join("\n") });
+                break;
+            }
+            case "message":
+                push({ ts, kind: "person", from: pick(p, "from") || "someone", to: ["room"], label: "says", text: pick(p, "body") });
+                break;
+            case "member.joined":
+                sys(ts, `${pick(p, "github") ? "@" + pick(p, "github") : pick(p, "name")} joined the room as ${pick(p, "role") || "member"}`);
+                break;
+            case "member.left":
+                sys(ts, `${pick(p, "name")} ${pick(p, "reason") || "left"}`);
+                break;
+            case "crew.updated":
+                sys(ts, `${pick(p, "member")}'s crew: ${list(p.agents).join(", ") || "(none)"}`);
+                break;
+            case "assign":
+                sys(ts, `offered ${q(pick(p.task ?? {}, "title") || title(e.task))} on ${pick(p, "worker") || "a teammate"}'s machine`);
+                break;
+            case "live.joined":
+                sys(ts, `${e.agent ?? "?"} joined live${pick(p, "branch") ? " on " + pick(p, "branch") : ""}`);
+                break;
+            case "live.left":
+                sys(ts, `${e.agent ?? "?"} left${pick(p, "why") ? " · " + pick(p, "why") : ""}`);
+                break;
+            case "live.released":
+                sys(ts, `${e.agent ?? "?"} released ${list(p.paths).join(", ")}`);
+                break;
+            case "context.added":
+                push({ ts, kind: "screen", from: pick(p, "by") || "you", to: ["shared screen"], label: `puts ${pick(p, "id")} ${q(pick(p, "title"))} on the shared screen`, text: pick(p, "summary") });
+                break;
+            case "context.note":
+                push({ ts, kind: "screen", from: pick(p, "by") || e.agent || "you", to: ["shared screen"], label: `pins a note on ${pick(p, "id")} ${q(pick(p, "title"))}`, text: pick(p, "body") });
+                break;
+            // ---- the scheduler ----
+            case "run.start": {
+                const a = pick(p, "agent") || e.agent || "?";
+                if (e.task)
+                    owner.set(e.task, a);
+                sys(ts, `${a} ${p.fixing ? "starts a fix round on" : p.round !== undefined ? `starts QA round ${str(p.round)} on` : "starts"} ${q(title(e.task, p))}${p.remote ? ` · on ${pick(p, "remote")}'s machine` : ""}${p.takeover ? ` · taking over from ${pick(p, "takeover")}` : ""}`, "", taskRef(e.task, p));
+                break;
+            }
+            case "run.declined":
+                sys(ts, `${pick(p, "agent") || e.agent} declined ${q(title(e.task, p))} · back on the board`, "", taskRef(e.task, p));
+                break;
+            case "run.review":
+                sys(ts, `${pick(p, "agent") || e.agent} reviews ${pick(p, "author")}'s ${q(title(e.task, p))}`, "", taskRef(e.task, p));
+                break;
+            case "run.reviewed": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                push({ ts, kind: "review", from: a, to: author ? [author] : [], label: p.skipped ? "review skipped" : p.approve === false ? "asks for changes" : `approves ${q(title(e.task, p))}`, text: pick(p, "notes"), ...taskRef(e.task, p) });
+                break;
+            }
+            case "run.merged":
+                push({ ts, kind: "merge", from: "huddle", to: [], label: `✓ merged ${pick(p, "agent") || e.agent}'s ${q(title(e.task, p))}`, text: [pick(p, "reason"), p.ms ? fmtDuration(Number(p.ms)) : "", p.tokens ? `${fmtTokens(Number(p.tokens))} tokens` : ""].filter(Boolean).join(" · "), ...taskRef(e.task, p) });
+                break;
+            case "run.failed":
+                push({ ts, kind: "fail", from: "huddle", to: [], label: `${p.needsYou ? "! needs you:" : "✗ failed:"} ${pick(p, "agent") || e.agent}'s ${q(title(e.task, p))}`, text: pick(p, "reason"), ...taskRef(e.task, p) });
+                break;
+            case "run.stuck":
+                push({ ts, kind: "fail", from: "huddle", to: [], label: "blocked by failures", text: list(p.blocked).join("\n") });
+                break;
+            case "run.conflict": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                sys(ts, `${a} resolves a merge conflict in ${author === a ? "its own" : author + "'s"} ${q(title(e.task, p))} (try ${str(p.attempt)})`, list(p.files).join(", "), taskRef(e.task, p));
+                break;
+            }
+            case "run.resolved":
+                sys(ts, `${p.ok ? "✓ conflict resolved" : "✗ resolution rejected"}: ${q(title(e.task, p))}`, pick(p, "reason"), taskRef(e.task, p));
+                break;
+            // ---- the design council ----
+            case "council.proposal":
+                push({ ts, kind: "proposal", from: pick(p, "agent", "from", "by") || e.agent || "?", to: ["council"], label: "proposes a design", text: [pick(p, "text", "summary", "title", "proposal", "body", "plan"), pick(p, "risks", "details", "why")].filter(Boolean).join("\n\n") }, "council");
+                break;
+            case "council.critique": {
+                const a = pick(p, "agent", "from", "by", "critic") || e.agent || "?";
+                const of = pick(p, "of", "target", "to", "author");
+                const text = pick(p, "text", "body", "critique", "summary", "flaws");
+                // Council v2: ADOPT / FLAW lines are their own messages; here, the rest of what it said.
+                const v2 = Array.isArray(p.adopts) || Array.isArray(p.flaws) || /^\s*ADOPT\W/m.test(text);
+                const revised = v2 ? /REVISED\W*:?\s*([\s\S]*)$/i.exec(text)?.[1]?.trim() : undefined;
+                if (v2 && !revised)
+                    break;
+                push({ ts, kind: "critique", from: a, to: of ? [of] : ["council"], label: revised ? "revised position" : `critiques ${of ? of + "'s proposal" : "the proposals"}`, text: revised ?? text }, "council");
+                break;
+            }
+            case "council.adopt":
+            case "council.flaw": {
+                const of = pick(p, "of");
+                push({ ts, kind: e.type === "council.adopt" ? "adopt" : "flaw", from: pick(p, "agent") || e.agent || "?", to: of ? [of] : [], label: e.type === "council.adopt" ? `adopts ${of}'s idea` : `finds a flaw in ${of}'s idea`, text: pick(p, "body", "text") }, "council");
+                break;
+            }
+            case "council.ratify": {
+                const obj = list(p.objections);
+                push({ ts, kind: "ratify", from: pick(p, "agent") || e.agent || "?", to: ["council"], label: obj.length ? "objects to the plan" : `ratifies the plan${pick(p, "verdict") === "unclear" ? " (no clear verdict)" : ""}`, text: obj.join("\n") }, "council");
+                break;
+            }
+            case "council.plan": {
+                const by = pick(p, "by", "agent", "merged_by") || e.agent || "council";
+                const tasks = Array.isArray(p.tasks) ? p.tasks : [];
+                const sy = p.synthesizer && typeof p.synthesizer === "object" ? p.synthesizer : null;
+                const objections = (Array.isArray(p.objections) ? p.objections : []).map((o) => `${o?.taken === true ? "✓ took" : "✗ kept the plan over"} ${str(o?.by)}'s objection: ${str(o?.objection)}`);
+                // The tasks themselves (with whose idea each was) are the PLAN message that follows.
+                const text = [
+                    sy?.why ? `${sy.kind === "agent" ? "chosen to write it" : "the brain wrote it"}: ${str(sy.why)}` : "",
+                    objections.join("\n"),
+                    pick(p, "summary", "note"),
+                ]
+                    .filter(Boolean)
+                    .join("\n\n");
+                push({ ts, kind: "plan", from: by, to: list(p.members).length ? list(p.members).filter((m) => m !== by) : ["council"], label: `writes the plan${tasks.length ? `: ${plural(tasks.length, "task")}` : ""}`, text }, "council");
+                break;
+            }
+            case "council.skipped":
+                sys(ts, `${pick(p, "agent") || e.agent || "?"}: ${pick(p, "round") || "council"} skipped`, pick(p, "reason") || "no answer");
+                break;
+            case "contract.set":
+                if (pick(p, "text"))
+                    push({ ts, kind: "contract", from: pick(p, "by") || e.agent || "council", to: ["all"], label: "writes the contract: the names every task codes to", text: str(p.text) }, working ? undefined : "council");
+                break;
+            case "contract.amended":
+                push({ ts, kind: "contract", from: pick(p, "by") || e.agent || "?", to: ["all"], label: `amends the contract (v${str(p.version)})`, text: [`${pick(p, "section")}: ${pick(p, "change")}`, pick(p, "why") ? `why: ${pick(p, "why")}` : ""].filter(Boolean).join("\n") });
+                break;
+            // ---- teamwork mid-task ----
+            case "checkpoint": {
+                const a = pick(p, "agent") || e.agent || "?";
+                const author = pick(p, "author");
+                const notes = pick(p, "notes");
+                const ok = !notes || /^LOOKS GOOD/i.test(notes.trim());
+                push({ ts, kind: "buddy", from: a, to: author ? [author] : [], label: `buddy check ${Number(p.pct) ? `at ${str(p.pct)}%` : "mid-task"} on ${q(title(e.task, p))}: ${ok ? "looks good" : p.late ? "notes (came back after it landed)" : "notes"}`, text: ok ? "" : notes, ...taskRef(e.task, p) });
+                break;
+            }
+            case "note.closed": {
+                const to = pick(p, "to") || e.agent || "?";
+                const by = pick(p, "by");
+                const how = pick(p, "how") || "ignored";
+                const what = pick(p, "kind") === "radar" ? "the radar's finding" : `${by}'s buddy note`;
+                push({ ts, kind: how === "ignored" ? "fail" : "system", from: "huddle", to: [], label: how === "ignored" ? `${to} never answered ${what} on ${q(title(e.task))}` : `${to} ${how === "replied" ? "answered" : "addressed (in code)"} ${what} on ${q(title(e.task))}`, text: "", ...taskRef(e.task) });
+                break;
+            }
+            case "done.refused":
+                sys(ts, `${e.agent ?? "?"} tried to finish ${q(title(e.task))} with ${plural(list(p.notes).length || 1, "teammate note")} unanswered · told to answer first`, "", taskRef(e.task));
+                break;
+            case "radar": {
+                const w = pick(p, "with");
+                push({ ts, kind: "radar", from: "huddle", to: [e.agent ?? pick(p, "agent"), ...(w && w !== "contract" ? [w] : [])].filter(Boolean), label: `radar: ${pick(p, "kind") === "overlap" ? "overlapping work" : "name mismatch"}${w ? ` (${e.agent ?? pick(p, "agent")} ↔ ${w})` : ""}`, text: pick(p, "detail"), ...taskRef(e.task) });
+                break;
+            }
+            case "pair":
+                push({ ts, kind: "system", from: pick(p, "agent") || e.agent || "?", to: pick(p, "with") ? [pick(p, "with")] : [], label: `pairs on ${q(title(e.task, p))}`, text: [pick(p, "part") ? `takes: ${pick(p, "part")}` : "", pick(p, "reason")].filter(Boolean).join("\n"), ...taskRef(e.task, p) });
+                break;
+            case "pair.dropped":
+                sys(ts, `${e.agent ?? "?"}'s offer to pair with ${pick(p, "with")} on ${q(title(e.task, p))} was dropped`, pick(p, "reason"), taskRef(e.task, p));
+                break;
+            case "task.takeover": {
+                const from = pick(p, "from");
+                const to = pick(p, "to") || e.agent || "?";
+                if (e.task)
+                    owner.set(e.task, to);
+                sys(ts, pick(p, "kind") === "split" ? `${to} takes part of ${from}'s ${q(title(e.task, p))}` : `${to} takes over ${q(title(e.task, p))} from ${from}`, pick(p, "reason"), taskRef(e.task, p));
+                break;
+            }
+            case "takeover":
+                if (roomTakeovers)
+                    break;
+                sys(ts, `${pick(p, "to", "agent", "by") || e.agent} takes over ${q(title(e.task, p))}${pick(p, "from", "was", "previous") ? ` from ${pick(p, "from", "was", "previous")}` : ""}`, pick(p, "reason", "why"), taskRef(e.task, p));
+                break;
+            case "task.split":
+                sys(ts, `${pick(p, "from") || e.agent} splits ${q(pick(p, "title"))} off ${q(pick(p, "parent_title"))}`, list(p.files).join(", "));
+                break;
+            case "split": {
+                const parts = Array.isArray(p.into) ? p.into : Array.isArray(p.parts) ? p.parts : Array.isArray(p.tasks) ? p.tasks : [];
+                sys(ts, `${pick(p, "from", "agent", "by") || e.agent} splits ${q(title(e.task, p))}${list(p.to ?? p.agents).length ? " → " + list(p.to ?? p.agents).join(", ") : ""}`, parts.map((x) => (typeof x === "string" ? x : pick(x ?? {}, "title", "id"))).join("\n"));
+                break;
+            }
+            // ---- QA ----
+            case "qa.round":
+                push({ ts, kind: "qa", from: "huddle", to: list(p.agents), label: `QA round${p.round !== undefined ? " " + str(p.round) : ""} on the merged build${list(p.agents).length ? ` · checked by ${list(p.agents).join(", ")}` : ""}`, text: pick(p, "summary", "checks", "note") }, "qa");
+                break;
+            case "qa.bug": {
+                const a = pick(p, "agent", "by", "found_by", "reporter") || e.agent || "?";
+                const to = pick(p, "to", "owner", "assigned_to", "author");
+                push({ ts, kind: "bug", from: a, to: to ? [to] : ["room"], label: `QA bug: ${pick(p, "title", "summary", "bug")}`, text: [pick(p, "repro", "details", "spec", "body"), pick(p, "expected") ? `expected: ${pick(p, "expected")}` : "", pick(p, "actual") ? `actual: ${pick(p, "actual")}` : ""].filter(Boolean).join("\n"), ...taskRef(e.task, p) });
+                break;
+            }
+            case "qa.done":
+                sys(ts, `${e.agent || pick(p, "agent")}: ${p.ok === false ? "QA check didn't finish" : "QA check done"} · ${plural(Number(p.bugs ?? 0), "bug")} filed`, p.ms ? fmtDuration(Number(p.ms)) : "");
+                break;
+            case "qa.clean":
+                push({ ts, kind: "qa", from: pick(p, "agent", "by") || e.agent || "huddle", to: [], label: `QA${p.round !== undefined ? " round " + str(p.round) : ""} clean`, text: pick(p, "summary", "note") });
+                break;
+            case "qa.suspect":
+                sys(ts, `QA round ${str(p.round)} came back clean, but quickly · another agent checks again`, pick(p, "reason"));
+                break;
+            case "qa.unchecked":
+                push({ ts, kind: "fail", from: "huddle", to: [], label: `QA round ${str(p.round)}: the build was NOT checked`, text: pick(p, "reason") });
+                break;
+            case "qa.capped":
+                sys(ts, `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.fixes":
+                sys(ts, `QA round ${str(p.round)} fixes: ${str(p.merged ?? 0)} merged, ${str(p.failed ?? 0)} failed`);
+                break;
+            case "qa.duplicate":
+                sys(ts, `${q(pick(p, "title"))} is a duplicate of ${q(title(pick(p, "of")))} · not filed again`);
+                break;
+            case "qa.fixed":
+            case "qa.fix":
+                push({ ts, kind: "qa", from: pick(p, "agent", "by", "fixed_by") || e.agent || "?", to: [], label: `fixed: ${pick(p, "title", "summary", "bug") || title(e.task)}`, text: "" });
+                break;
+            default: {
+                // Newer (or unknown) events: every field, so nothing a run recorded is lost.
+                const fields = Object.entries(p)
+                    .filter(([, v]) => v !== null && v !== undefined && v !== "")
+                    .map(([k, v]) => `${k}: ${str(v)}`)
+                    .join("\n");
+                const a = pick(p, "agent", "from", "by") || e.agent || "huddle";
+                push({ ts, kind: "system", from: a, to: pick(p, "to") ? [pick(p, "to")] : [], label: `[${e.type}]${e.task ? " " + q(title(e.task)) : ""}`, text: fields });
+            }
+        }
+    }
+    if (!planned)
+        plan(run.events.find((e) => e.type === "plan.made")?.ts ?? run.start);
+    const RANK = { goal: 0, council: 1, plan: 2, build: 3, qa: 3 };
+    const phased = out.map((m, k) => {
+        return { m, k, phase: phaseOf.get(m) };
+    });
+    // The council is recorded in one go when it ends, at the instant the plan lands: goal → council → plan, then time order.
+    phased.sort((a, b) => RANK[a.phase] - RANK[b.phase] || a.m.ts - b.m.ts || a.k - b.k);
+    return phased.map(({ m, phase }, i) => ({ i: i + 1, t: clock(m.ts - run.start), phase, ...m }));
+}
+// ---- transcripts -----------------------------------------------------------------
+/** Each agent session in the run (a task, a fix round, a QA check), with its log. */
+export function sessionsOf(run) {
+    const seen = new Map();
+    const titles = new Map();
+    for (const e of run.events)
+        if (e.type === "task.added")
+            titles.set(pick(e.p, "id") || e.task || "", pick(e.p, "title"));
+    for (const e of run.events) {
+        if (!["run.start", "run.conflict", "task.claimed"].includes(e.type))
+            continue;
+        const agent = pick(e.p, "agent") || e.agent || "";
+        const task = e.task || pick(e.p, "task");
+        if (!agent || !task)
+            continue;
+        const log = pick(e.p, "log");
+        const key = log ? path.basename(log, ".log") : `${agent}-${task}`.replace(/[^\w.-]/g, "_");
+        if (!seen.has(key))
+            seen.set(key, { agent, task, title: pick(e.p, "title") || titles.get(task) || task, log });
+    }
+    return [...seen.entries()].map(([key, s]) => ({ ...s, log: s.log || key + ".log" }));
+}
+function transcriptsOf(run, logsDir, repoRoot) {
+    const out = {};
+    const specs = new Map();
+    for (const e of run.events)
+        if (e.type === "task.added")
+            specs.set(pick(e.p, "id") || e.task || "", pick(e.p, "spec"));
+    for (const s of sessionsOf(run)) {
+        const key = path.basename(s.log, ".log");
+        // Where it was written (absolute, maybe another machine's path) — else the same name in this repo's logs/.
+        const local = path.join(logsDir, path.basename(s.log));
+        const file = fs.existsSync(local) ? local : path.isAbsolute(s.log) && fs.existsSync(s.log) ? s.log : local;
+        const parsed = readLog(file, s.agent);
+        const rel = path.relative(repoRoot, file);
+        out[key] = {
+            agent: s.agent,
+            task: s.task,
+            title: s.title,
+            spec: specs.get(s.task) ?? "",
+            file: rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : file,
+            found: !!parsed,
+            format: parsed?.format ?? "raw",
+            bytes: parsed?.bytes ?? 0,
+            turns: parsed?.turns ?? [],
+        };
+    }
+    return out;
+}
+// ---- the document ----------------------------------------------------------------
+/** Every string in `v`, through the shared screen's secret scanner. */
+function redactDeep(v, count) {
+    if (typeof v === "string") {
+        const r = redactSecrets(v);
+        count.n += r.count;
+        return r.text;
+    }
+    if (Array.isArray(v))
+        return v.map((x) => redactDeep(x, count));
+    if (v && typeof v === "object") {
+        const o = {};
+        for (const [k, x] of Object.entries(v))
+            o[k] = redactDeep(x, count);
+        return o;
+    }
+    return v;
+}
+/** One run as an export document (the JSON schema above); render it with renderExport. */
+export function buildExport(run, runs, opts) {
+    const s = buildStory(run, runs);
+    const o = outcome(s);
+    const crew = crewRows(s);
+    const doneBy = new Map();
+    for (const e of run.events) {
+        if (!e.task)
+            continue;
+        if (e.type === "run.merged")
+            doneBy.set(e.task, { agent: pick(e.p, "agent") || e.agent || "", status: "merged" });
+        else if (e.type === "run.failed" && doneBy.get(e.task)?.status !== "merged")
+            doneBy.set(e.task, { agent: pick(e.p, "agent") || e.agent || "", status: p2(e.p) });
+        else if (e.type === "task.status" && ["merged", "failed"].includes(pick(e.p, "status")) && !doneBy.has(e.task))
+            doneBy.set(e.task, { agent: e.agent || "", status: pick(e.p, "status") });
+    }
+    const contractEv = [...run.events].reverse().find((e) => e.type === "contract.set" && pick(e.p, "text"));
+    const doc = {
+        schema: "huddle.export",
+        version: EXPORT_SCHEMA_VERSION,
+        level: opts.level,
+        generated: new Date().toISOString(),
+        redacted: 0,
+        run: { index: run.index, of: runs, id: run.id, goal: run.goal, title: headline(run.goal), start: run.start, end: run.end, ms: run.end - run.start },
+        agents: s.agents.map((a) => ({ id: a, color: colorOf(a), qa: crew.find((c) => c.agent === a)?.qa ?? 0, ...s.stats.get(a) })),
+        summary: {
+            result: { merged: s.merged, failed: s.failed, merges: o.merges, green: o.green, qaRounds: o.rounds, qa: o.qa, tokens: o.tokens, cached: o.cached, ms: o.ms },
+            plan: {
+                by: s.plan.by ?? "",
+                tasks: s.plan.tasks.map((t) => ({ id: t.id, title: t.title, deps: t.deps, files: t.files, prefers: t.prefers, idea: t.by ?? "", doneBy: doneBy.get(t.id)?.agent ?? "", status: doneBy.get(t.id)?.status ?? "" })),
+            },
+            decisions: decisionsOf(run, s),
+            contract: s.collab.contract || s.collab.amendments.length ? { by: s.collab.contract?.by ?? "", text: contractEv ? str(contractEv.p.text) : "", amendments: s.collab.amendments } : null,
+            teamwork: { tally: tally(s).map((t) => ({ n: t.n, label: t.label })), lines: teamworkLines(s) },
+            cost: crew.map((c) => ({ agent: c.agent, tokens: c.tokens, cached: c.cached, ms: c.ms })),
+        },
+        messages: opts.level === "summary" ? [] : chatOf(run, s),
+        transcripts: opts.level === "full" ? transcriptsOf(run, opts.logsDir, opts.repoRoot) : {},
+    };
+    if (opts.redact === false)
+        return doc;
+    const count = { n: 0 };
+    const clean = redactDeep(doc, count);
+    clean.redacted = count.n;
+    return clean;
+}
+const p2 = (p) => (p.needsYou ? "needs you" : "failed");
+/** The council's decisions and risks, whole (the story's timeline shortens them). */
+function decisionsOf(run, s) {
+    const whole = run.events
+        .filter((e) => e.type === "memory.added" && pick(e.p, "author") === "council")
+        .map((e) => {
+        const body = pick(e.p, "body");
+        const risk = /^council risk:/.test(body) || pick(e.p, "kind") === "gotcha";
+        return { risk, by: risk ? /flagged by (\S+)/.exec(pick(e.p, "why"))?.[1] ?? "" : "", body: body.replace(/^council( risk)?:\s*/, "") };
+    });
+    if (whole.length)
+        return whole;
+    return phases(s).agreed.map((it) => {
+        const a = agreement(it);
+        return { risk: a.risk, by: a.by ?? "", body: a.body };
+    });
+}
+/**
+ * The teamwork, line by line and whole: every idea taken and flaw found,
+ * objections, buddy notes and what came of them, the radar, QA's bugs, pairs.
+ * (collabLines is the same list shortened for a terminal.)
+ */
+export function teamworkLines(s) {
+    const c = s.collab;
+    const out = [];
+    for (const a of c.adopts)
+        out.push({ label: "adopted", text: `${a.by} took ${a.of}'s idea: ${a.text}` });
+    for (const f of c.flaws)
+        out.push({ label: "flaw", text: `${f.by} on ${f.of}'s idea: ${f.text}` });
+    if (c.synthesizer)
+        out.push({ label: "plan by", text: `${c.synthesizer.id}${c.synthesizer.why ? ` — ${c.synthesizer.why}` : ""}` });
+    for (const r of c.ratify)
+        out.push({ label: "ratify", text: r.verdict === "object" ? `${r.agent} objected: ${r.objections.join(" · ")}` : `${r.agent} ratified${r.verdict === "unclear" ? " (no clear verdict)" : ""}` });
+    for (const o of c.objections)
+        out.push({ label: "revision", text: `${o.taken ? "took" : "kept the plan over"} ${o.by}'s objection: ${o.objection}` });
+    for (const a of c.amendments)
+        out.push({ label: "contract", text: `v${a.version} by ${a.by}: ${a.change}` });
+    for (const b of buddyNotes(s))
+        out.push({ label: "buddy", text: `${b.agent} → ${b.author} at ${b.pct}% (${b.how}): ${b.notes}` });
+    const good = c.buddy.filter((b) => !b.notes).length;
+    if (good)
+        out.push({ label: "buddy", text: `${plural(good, "check")} looked good` });
+    for (const r of c.radar)
+        out.push({ label: "radar", text: `${r.kind === "overlap" ? "overlap" : "name mismatch"} ${r.agent} ↔ ${r.with}: ${r.detail}` });
+    if (!c.radar.length && c.radarLooks?.looks)
+        out.push({ label: "radar", text: `no catches · compared 2+ agents' work in progress ${plural(c.radarLooks.looks, "time")}` });
+    for (const f of c.followups.filter((x) => x.kind === "radar"))
+        out.push({ label: "radar", text: `${f.to} ${f.how === "ignored" ? "ignored" : f.how === "replied" ? "answered" : "fixed"} the radar's finding: ${f.note}` });
+    for (const b of c.bugs)
+        out.push({ label: "QA bug", text: `${b.by} found${b.to ? ` (fix for ${b.to})` : ""}: ${b.title}${b.fixedBy ? ` — fixed by ${b.fixedBy}` : " — still open"}` });
+    for (const p of c.pairs)
+        out.push({ label: "pair", text: `${p.agent} helped ${p.with}: ${p.part}` });
+    if (c.credit.size)
+        out.push({ label: "credit", text: [...c.credit.entries()].sort((a, b) => b[1] - a[1]).map(([a, k]) => `${a} ${plural(k, "task")}`).join(" · ") });
+    return out.length ? out : collabLines(s);
+}
+/** Which run: a number from `huddle runs`, a session id, "latest" (or nothing). */
+export function findRun(runs, which) {
+    if (which === undefined || which === "" || which === "latest")
+        return runs.at(-1);
+    return pickRun(runs, String(which));
+}
+/**
+ * A run as a document, for any caller (the CLI, the hand-off brief, a dashboard).
+ * Throws when the run isn't there.
+ */
+export function exportRun(db, runId, opts = {}) {
+    const runs = splitRuns(db.allEvents());
+    const run = findRun(runs, runId);
+    if (!run)
+        throw new Error(runs.length ? `no run ${runId} (there are ${runs.length})` : "no runs yet");
+    const huddle = path.dirname(db.path);
+    const doc = buildExport(run, runs.length, {
+        ...opts,
+        level: opts.level ?? "chat",
+        logsDir: opts.logsDir ?? path.join(huddle, "logs"),
+        repoRoot: opts.repoRoot ?? (path.basename(huddle) === ".huddle" ? path.dirname(huddle) : huddle),
+    });
+    return renderExport(doc, opts.format ?? "md");
+}
+export function renderExport(doc, format) {
+    return format === "json" ? JSON.stringify(doc, null, 2) + "\n" : format === "html" ? renderExportHtml(doc) : renderMarkdown(doc);
+}
+// ---- Markdown ----------------------------------------------------------------------
+const PHASE_NAME = { goal: "GOAL", council: "COUNCIL", plan: "PLAN", build: "BUILD", qa: "QA" };
+const PHASE_SUB = {
+    goal: "what was asked",
+    council: "the agents design it together before anyone codes",
+    plan: "who does what",
+    build: "agents code, check each other, merge",
+    qa: "agents re-check the merged build; bugs become fix tasks",
+};
+/** A fence longer than any run of backticks inside. */
+const fence = (s) => "`".repeat(Math.max(3, ...[...s.matchAll(/`+/g)].map((m) => m[0].length + 1)));
+const code = (s, lang = "text") => {
+    const f = fence(s);
+    return `${f}${lang}\n${s.replace(/\s+$/, "")}\n${f}`;
+};
+const quote = (s) => s
+    .replace(/\s+$/, "")
+    .split("\n")
+    .map((l) => (l ? `> ${l}` : ">"))
+    .join("\n");
+/** Inline text in Markdown: no accidental emphasis or HTML from names and labels. */
+const md = (s) => s.replace(/([\\`*_<>[\]|])/g, "\\$1");
+/** A list item whose text may run over several lines: the rest stays inside the item. */
+const li = (s) => "- " + s.replace(/\s+$/, "").replace(/\n/g, "\n  ");
+const toLine = (m) => (m.to.length ? ` → ${m.to.map(md).join(", ")}` : "");
+function header(doc) {
+    const r = doc.run;
+    const res = doc.summary.result;
+    const out = [
+        `# ${md(r.title || "(no goal)")}`,
+        "",
+        `_Huddle run ${r.index} of ${r.of}${r.id ? ` · ${r.id}` : ""} · ${new Date(r.start).toLocaleString()} · ${fmtDuration(r.ms)} · ${doc.agents.map((a) => a.id).join(", ") || "no agents"} · exported at level “${doc.level}”${doc.redacted ? ` · ${plural(doc.redacted, "likely secret")} redacted` : ""}_`,
+        "",
+        `**Result:** ${res.failed ? "◎" : "✓"} ${res.merged} merged, ${res.failed} failed${res.merges ? ` · ${res.green}/${res.merges} merged on green tests` : ""}${res.tokens ? ` · ${fmtTokens(res.tokens)} tokens` : ""}${res.qa ? ` · ${plural(res.qaRounds, "QA round")}: ${res.qa.text}` : ""}`,
+    ];
+    if (r.goal.trim() !== r.title)
+        out.push("", "<details><summary>The goal, as typed</summary>", "", code(r.goal), "", "</details>");
+    return out;
+}
+function summaryMd(doc) {
+    const s = doc.summary;
+    const out = ["", "## Summary"];
+    if (doc.agents.length) {
+        out.push("", "### Who did what", "", "| agent | merged | failed | reviews | QA | msgs sent/got | ideas proposed/critiques | bugs found/fixed | tool calls | time | tokens |", "|---|---|---|---|---|---|---|---|---|---|---|");
+        for (const a of doc.agents)
+            out.push(`| ${md(a.id)} | ${a.merged} | ${a.failed} | ${a.reviews}${a.changesAsked ? ` (${a.changesAsked} asked for changes)` : ""} | ${a.qa} | ${a.sent}/${a.received} | ${a.proposals}/${a.critiques} | ${a.bugsFound}/${a.bugsFixed} | ${a.toolCalls} | ${a.ms ? fmtDuration(a.ms) : "—"} | ${a.tokens ? fmtTokens(a.tokens) : "—"} |`);
+    }
+    if (s.plan.tasks.length) {
+        out.push("", `### Plan${s.plan.by ? ` · by ${md(s.plan.by)}` : ""}`, "");
+        const num = new Map(s.plan.tasks.map((t, i) => [t.id, i + 1]));
+        s.plan.tasks.forEach((t, i) => {
+            const bits = [
+                t.doneBy ? `${t.status === "merged" ? "✓" : "✗"} ${t.status} · ${t.doneBy}` : "",
+                t.idea ? `idea from ${t.idea}` : "",
+                t.deps.length ? `after ${t.deps.map((d) => "#" + (num.get(d) ?? d)).join(", ")}` : "",
+                t.files.length ? t.files.map((f) => "`" + f + "`").join(", ") : "",
+            ].filter(Boolean);
+            out.push(`${i + 1}. **${md(t.title)}**${bits.length ? " — " + bits.join(" · ") : ""}`);
+        });
+    }
+    if (s.decisions.length) {
+        out.push("", "### Decisions", "");
+        for (const d of s.decisions)
+            out.push(li(`${d.risk ? `**risk**${d.by ? ` (${md(d.by)})` : ""}:` : "**decided:**"} ${d.body}`));
+    }
+    if (s.contract) {
+        out.push("", `### Contract${s.contract.by ? ` · by ${md(s.contract.by)}` : ""}`, "");
+        if (s.contract.text)
+            out.push("<details><summary>The contract every task coded to</summary>", "", code(s.contract.text, "markdown"), "", "</details>");
+        for (const a of s.contract.amendments)
+            out.push(li(`v${a.version} by ${md(a.by)}: ${a.change}`));
+    }
+    if (s.teamwork.tally.length || s.teamwork.lines.length) {
+        out.push("", "### Teamwork", "");
+        if (s.teamwork.tally.length)
+            out.push(s.teamwork.tally.map((t) => `**${t.n}** ${t.label}`).join(" · "), "");
+        for (const l of s.teamwork.lines)
+            out.push(li(`${l.label ? `**${md(l.label)}** ` : ""}${l.text}`));
+    }
+    if (s.cost.some((c) => c.tokens || c.ms)) {
+        const tot = s.cost.reduce((n, c) => n + c.tokens, 0);
+        const cached = s.cost.reduce((n, c) => n + c.cached, 0);
+        out.push("", "### Cost", "", "| agent | tokens | of which cached | agent time |", "|---|---|---|---|");
+        for (const c of s.cost)
+            out.push(`| ${md(c.agent)} | ${c.tokens ? fmtTokens(c.tokens) : "—"} | ${c.cached ? fmtTokens(c.cached) : "—"} | ${c.ms ? fmtDuration(c.ms) : "—"} |`);
+        out.push(`| **all** | **${fmtTokens(tot)}** | ${fmtTokens(cached)} | ${fmtDuration(doc.run.ms)} start to finish |`);
+    }
+    return out;
+}
+function chatMd(doc) {
+    const out = ["", "## Chat", "", `_${plural(doc.messages.length, "message")}, in time order. Times are from the start of the run._`];
+    let phase = null;
+    for (const m of doc.messages) {
+        if (m.phase !== phase) {
+            phase = m.phase;
+            out.push("", `### ${PHASE_NAME[phase]} · ${PHASE_SUB[phase]}`);
+        }
+        const head = `**${md(m.from)}${toLine(m)}** · ${md(m.label)}${m.replyTo ? ` _(re: ${md(m.replyTo)})_` : ""} · \`${m.t}\``;
+        out.push("", head);
+        if (m.text)
+            out.push("", quote(m.text));
+    }
+    return out;
+}
+function transcriptsMd(doc) {
+    const list = Object.entries(doc.transcripts);
+    const out = ["", "## Sessions", "", `_Each agent's own session, per task: what it said, read, ran and wrote. Long outputs are cut (the whole thing is in the log)._`];
+    if (!list.length)
+        out.push("", "_No agent sessions in this run._");
+    for (const [key, t] of list) {
+        out.push("", `### ${md(t.agent)} · ${md(t.title)} · \`${key}\``, "", `_${t.found ? `${t.format === "raw" ? "plain text" : t.format + " log"} · ${plural(t.turns.length, "step")} · ${Math.max(1, Math.round(t.bytes / 1024))} KB` : "log not found"} · ${md(t.file)}_`);
+        if (t.spec)
+            out.push("", "<details><summary>The task, as given</summary>", "", code(t.spec), "", "</details>");
+        for (const turn of t.turns)
+            out.push("", ...turnMd(t.agent, turn));
+    }
+    return out;
+}
+function turnMd(agent, t) {
+    switch (t.kind) {
+        case "prompt":
+            return ["<details><summary>The prompt Huddle gave it</summary>", "", code(t.text), "", "</details>"];
+        case "text":
+            return [`**${md(agent)}:**`, "", quote(t.text)];
+        case "thinking":
+            return [`_${md(agent)} thinks:_`, "", quote(t.text.split("\n").map((l) => (l ? `_${l.replace(/_/g, "\\_")}_` : l)).join("\n"))];
+        case "tool": {
+            const head = `${t.error ? "✗" : "▸"} **${md(t.tool ?? "tool")}**${t.about ? ` _${md(t.about)}_` : ""}${t.input ? " " + (t.input.includes("\n") || t.input.length > 160 ? "" : "`" + t.input.replace(/`/g, "'") + "`") : ""}`;
+            const long = t.input && (t.input.includes("\n") || t.input.length > 160);
+            return [head, ...(long ? ["", code(t.input)] : []), ...(t.output ? ["", code(t.output)] : [])];
+        }
+        case "end":
+            return [`_— ${md(t.text)}_`];
+        default:
+            return [`_${md(t.text.split("\n")[0])}_${t.text.includes("\n") ? "\n\n" + code(t.text.split("\n").slice(1).join("\n")) : ""}`];
+    }
+}
+export function renderMarkdown(doc) {
+    const out = [...header(doc), ...summaryMd(doc)];
+    if (doc.level !== "summary")
+        out.push(...chatMd(doc));
+    if (doc.level === "full")
+        out.push(...transcriptsMd(doc));
+    out.push("", "---", `_Exported by huddle export · ${doc.generated}_`, "");
+    return out.join("\n");
+}
+// ---- HTML ----------------------------------------------------------------------------
+const EXPORT_CSS = `
+.filter{position:sticky;top:0;z-index:5;display:flex;flex-wrap:wrap;gap:6px;align-items:center;padding:10px 0;margin:18px 0 0;background:var(--bg);border-bottom:1px solid var(--line)}
+.filter b{font-size:12px;color:var(--mute);font-weight:600;margin-right:4px}
+.filter input{position:absolute;opacity:0;pointer-events:none}
+.filter label{display:inline-flex;align-items:center;gap:6px;font-size:13px;font-weight:600;border:1px solid var(--line);border-radius:999px;padding:3px 11px;cursor:pointer;user-select:none;background:var(--card)}
+.filter label i{width:9px;height:9px;border-radius:50%;background:var(--c)}
+.filter input:not(:checked)+label{opacity:.45;text-decoration:line-through}
+.filter input:focus-visible+label{outline:2px solid var(--brand)}
+.filter a{font-size:13px;color:var(--brand);margin-left:auto;text-decoration:none}
+.chat{display:flex;flex-direction:column;gap:8px}
+.msg{background:var(--card);border:1px solid var(--line);border-left:4px solid var(--c);border-radius:12px;padding:8px 12px;min-width:0}
+.msg .meta{display:flex;flex-wrap:wrap;gap:4px 8px;align-items:baseline;font-size:13px;color:var(--mute)}
+.msg .meta .label{color:var(--fg);font-weight:600}
+.msg .meta time{margin-left:auto;font-variant-numeric:tabular-nums;font-size:12px}
+.msg .body{margin-top:6px;font-size:14px;white-space:pre-wrap;word-break:break-word;overflow-wrap:anywhere}
+.msg.sys{background:transparent;border:0;border-left:3px solid var(--line);border-radius:0;padding:3px 12px}
+.msg.sys .meta .label{color:var(--mute);font-weight:400}.msg.sys .body{font-size:13px;color:var(--mute);margin-top:2px}
+.msg.k-merge .label{color:var(--ok)!important}.msg.k-fail .label{color:var(--bad)!important}.msg.k-bug .label,.msg.k-radar .label,.msg.k-flaw .label{color:var(--warn)!important}
+.msg.k-adopt .label{color:var(--ok)!important}
+.msg .re{font-style:italic}
+.msg .body.long{max-height:22em;overflow:auto}
+.tx{margin:10px 0}
+.tx summary{display:flex;flex-wrap:wrap;gap:6px 10px;align-items:baseline}
+.tx summary small{margin:0}
+.turns{display:flex;flex-direction:column;gap:6px;margin-top:10px}
+.turn{font-size:14px;min-width:0}
+.turn.text{background:var(--soft);border-radius:10px;padding:8px 10px;white-space:pre-wrap;word-break:break-word;overflow-wrap:anywhere}
+.turn.thinking{color:var(--mute);font-style:italic;white-space:pre-wrap;word-break:break-word;border-left:3px solid var(--line);padding-left:10px}
+.turn.tool .call{font:13px/1.45 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;white-space:pre-wrap;overflow-wrap:anywhere}
+.turn.tool .about{font:italic 13px/1.4 ui-sans-serif,system-ui,sans-serif;color:var(--mute)}
+.turn.tool .call b{font-family:ui-sans-serif,system-ui,sans-serif}
+.turn.tool.err .call b{color:var(--bad)}
+.turn pre,.msg pre{margin:4px 0 0;padding:8px 10px;background:var(--soft);border-radius:8px;font:12px/1.45 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;white-space:pre-wrap;word-break:break-word;overflow-wrap:anywhere;max-height:24em;overflow:auto}
+.turn details{border:0;background:none;padding:0;margin:2px 0 0}.turn details summary{font-weight:400;font-size:12px;color:var(--mute)}
+.turn.note,.turn.end{font-size:12px;color:var(--mute)}
+.summary table td{white-space:normal}
+.plan li .badge{margin-left:6px}
+`;
+function filterRules(senders) {
+    // Unchecked = that sender's messages (and sessions) hidden. No script: :has() on the body.
+    return senders.map((a, i) => `body:has(#f${i}:not(:checked)) [data-from="${esc(a)}"]{display:none}`).join("\n");
+}
+export function renderExportHtml(doc) {
+    const r = doc.run;
+    const s = doc.summary;
+    const res = s.result;
+    const chip = (a) => `<span class="who"><i style="background:${colorOf(isCrew(doc, a) ? a : null)}"></i>${esc(a)}</span>`;
+    const badge = (text, tone = "") => `<span class="badge ${tone}">${esc(text)}</span>`;
+    const card = (title, body) => `<div class="card"><h3>${esc(title)}</h3>${body}</div>`;
+    const kpis = [
+        { n: String(res.merged), l: "merged", tone: "ok" },
+        { n: String(res.failed), l: "failed", tone: res.failed ? "bad" : "" },
+        ...(res.merges ? [{ n: `${res.green}/${res.merges}`, l: "merged on green tests", tone: res.green === res.merges ? "ok" : "warn" }] : []),
+        { n: fmtDuration(res.ms), l: "start to finish", tone: "" },
+        ...(res.tokens ? [{ n: fmtTokens(res.tokens), l: "tokens", tone: "" }] : []),
+        ...(doc.level !== "summary" ? [{ n: String(doc.messages.length), l: "messages", tone: "" }] : []),
+    ]
+        .map((k) => `<div class="kpi ${k.tone}"><b>${esc(k.n)}</b><span>${esc(k.l)}</span></div>`)
+        .join("");
+    const crew = doc.agents
+        .map((a) => `<div class="agent" style="--c:${a.color}"><div class="an"><i></i>${esc(a.id)}</div><div class="as">${esc([`${a.merged} merged`, a.failed ? `${a.failed} failed` : "", a.reviews ? plural(a.reviews, "review") : "", a.qa ? `${a.qa} QA` : "", a.sent ? plural(a.sent, "msg") + " sent" : ""].filter(Boolean).join(" · "))}</div><div class="am">${esc([a.ms ? fmtDuration(a.ms) : "", a.tokens ? fmtTokens(a.tokens) + " tok" : ""].filter(Boolean).join(" · ") || "—")}</div></div>`)
+        .join("");
+    // ---- summary
+    const num = new Map(s.plan.tasks.map((t, i) => [t.id, i + 1]));
+    const plan = s.plan.tasks.length
+        ? card(`Plan${s.plan.by ? " · by " + s.plan.by : ""}`, `<ol class="plan">${s.plan.tasks
+            .map((t) => `<li><b>${esc(t.title)}</b>${t.doneBy ? badge(`${t.status} · ${t.doneBy}`, t.status === "merged" ? "ok" : "bad") : ""}${t.idea ? ` <small>idea from ${esc(t.idea)}</small>` : ""}${t.deps.length ? ` <small>after ${esc(t.deps.map((d) => "#" + (num.get(d) ?? d)).join(", "))}</small>` : ""}${t.files.length ? `<div class="detail">${esc(t.files.join(", "))}</div>` : ""}</li>`)
+            .join("")}</ol>`)
+        : "";
+    const decisions = s.decisions.length ? card("Decisions", `<ul class="list">${s.decisions.map((d) => `<li>${d.risk ? badge(`risk${d.by ? " · " + d.by : ""}`, "warn") : badge("decided", "ok")} ${esc(d.body)}</li>`).join("")}</ul>`) : "";
+    const contract = s.contract
+        ? card(`Contract${s.contract.by ? " · by " + s.contract.by : ""}`, `${s.contract.text ? `<details><summary>The contract every task coded to</summary><pre>${esc(s.contract.text)}</pre></details>` : ""}${s.contract.amendments.length ? `<ul class="list">${s.contract.amendments.map((a) => `<li>◆ v${a.version} by ${chip(a.by)} <span class="detail">${esc(a.change)}</span></li>`).join("")}</ul>` : ""}`)
+        : "";
+    const team = s.teamwork.lines.length ? card("Teamwork", `<table class="team">${s.teamwork.lines.map((l) => `<tr><th>${esc(l.label)}</th><td>${esc(l.text)}</td></tr>`).join("")}</table>`) : "";
+    const tiles = s.teamwork.tally.length ? `<div class="tiles">${s.teamwork.tally.map((t) => `<div class="tile"><b>${esc(t.n)}</b><span>${esc(t.label)}</span></div>`).join("")}</div>` : "";
+    const cost = s.cost.some((c) => c.tokens || c.ms)
+        ? card("Cost", `<table><tr><th>agent</th><th>tokens</th><th>cached</th><th>time</th></tr>${s.cost.map((c) => `<tr><th>${chip(c.agent)}</th><td>${c.tokens ? esc(fmtTokens(c.tokens)) : "—"}</td><td>${c.cached ? esc(fmtTokens(c.cached)) : "—"}</td><td>${c.ms ? esc(fmtDuration(c.ms)) : "—"}</td></tr>`).join("")}<tr><th>all</th><td><b>${esc(fmtTokens(s.cost.reduce((n, c) => n + c.tokens, 0)))}</b></td><td>${esc(fmtTokens(s.cost.reduce((n, c) => n + c.cached, 0)))}</td><td>${esc(fmtDuration(r.ms))}</td></tr></table>`)
+        : "";
+    const whoTable = doc.agents.length
+        ? `<div class="scroll card"><table><tr><th>agent</th><th>merged</th><th>failed</th><th>reviews</th><th>QA</th><th>msgs out/in</th><th>proposals/critiques</th><th>bugs found/fixed</th><th>tool calls</th><th>time</th><th>tokens</th></tr>${doc.agents
+            .map((a) => `<tr><th>${chip(a.id)}</th><td>${a.merged}</td><td>${a.failed}</td><td>${a.reviews}</td><td>${a.qa}</td><td>${a.sent}/${a.received}</td><td>${a.proposals}/${a.critiques}</td><td>${a.bugsFound}/${a.bugsFixed}</td><td>${a.toolCalls}</td><td>${a.ms ? esc(fmtDuration(a.ms)) : "—"}</td><td>${a.tokens ? esc(fmtTokens(a.tokens)) : "—"}</td></tr>`)
+            .join("")}</table></div>`
+        : "";
+    // ---- the chat
+    const senders = [...new Set([...doc.messages.map((m) => m.from), ...Object.values(doc.transcripts).map((t) => t.agent)])];
+    const order = (a) => (isCrew(doc, a) ? 0 : a === "huddle" ? 2 : 1);
+    senders.sort((a, b) => order(a) - order(b));
+    const filter = doc.level === "summary" || !senders.length
+        ? ""
+        : `<nav class="filter" aria-label="show messages from"><b>show</b>${senders
+            .map((a, i) => `<input type="checkbox" id="f${i}" checked><label for="f${i}" style="--c:${colorOf(isCrew(doc, a) ? a : null)}"><i></i>${esc(a)}</label>`)
+            .join("")}<a href="#top">↑ top</a></nav>`;
+    const SYS = new Set(["system", "merge", "fail", "qa"]);
+    let phase = null;
+    const parts = [];
+    for (const m of doc.messages) {
+        if (m.phase !== phase) {
+            if (phase)
+                parts.push("</div></section>");
+            phase = m.phase;
+            parts.push(`<section class="phase"><h3><span class="tag">${PHASE_NAME[phase]}</span> ${esc(PHASE_SUB[phase])}</h3><div class="chat">`);
+        }
+        const sys = SYS.has(m.kind) && m.from === "huddle";
+        parts.push(`<div class="msg k-${esc(m.kind)}${sys ? " sys" : ""}" id="m${m.i}" data-from="${esc(m.from)}" style="--c:${colorOf(isCrew(doc, m.from) ? m.from : null)}"><div class="meta">${chip(m.from)}${m.to.length ? ` <span class="arrow">→</span> ${m.to.map(chip).join(" ")}` : ""} <span class="label">${esc(m.label)}</span>${m.replyTo ? ` <span class="re">re: ${esc(m.replyTo)}</span>` : ""}<time>${esc(m.t)}</time></div>${m.text ? `<div class="body${m.text.length > 2500 ? " long" : ""}">${esc(m.text)}</div>` : ""}</div>`);
+    }
+    if (phase)
+        parts.push("</div></section>");
+    const chat = doc.level === "summary" ? "" : `<h2 id="chat">Chat <small>${plural(doc.messages.length, "message")} in time order · times from the start</small></h2>${parts.join("") || '<p class="none">nothing was said in this run</p>'}`;
+    // ---- sessions
+    const turnHtml = (t) => {
+        switch (t.kind) {
+            case "prompt":
+                return `<li class="turn note"><details><summary>the prompt Huddle gave it</summary><pre>${esc(t.text)}</pre></details></li>`;
+            case "text":
+                return `<li class="turn text">${esc(t.text)}</li>`;
+            case "thinking":
+                return `<li class="turn thinking">${esc(t.text)}</li>`;
+            case "tool": {
+                const long = (t.output ?? "").split("\n").length > 6 || (t.output ?? "").length > 500;
+                const out = t.output ? (long ? `<details><summary>output · ${plural(t.output.split("\n").length, "line")}</summary><pre>${esc(t.output)}</pre></details>` : `<pre>${esc(t.output)}</pre>`) : "";
+                return `<li class="turn tool${t.error ? " err" : ""}"><div class="call">${t.error ? "✗" : "▸"} <b>${esc(t.tool ?? "tool")}</b>${t.about ? ` <span class="about">${esc(t.about)}</span>` : ""} ${esc(t.input ?? "")}</div>${out}</li>`;
+            }
+            default:
+                return `<li class="turn ${t.kind}">${esc(t.text)}</li>`;
+        }
+    };
+    const sessions = Object.entries(doc.transcripts)
+        .map(([key, t]) => `<details class="tx" data-from="${esc(t.agent)}"><summary>${chip(t.agent)} <span>${esc(t.title)}</span> <small>${esc(key)} · ${t.found ? `${esc(t.format === "raw" ? "plain text" : t.format)} · ${plural(t.turns.length, "step")} · ${Math.max(1, Math.round(t.bytes / 1024))} KB` : "log not found"}</small></summary>${t.spec ? `<details><summary>the task, as given</summary><pre>${esc(t.spec)}</pre></details>` : ""}<ol class="turns">${t.turns.map(turnHtml).join("")}</ol><p class="legend">${esc(t.file)}</p></details>`)
+        .join("");
+    const transcripts = doc.level === "full" ? `<h2 id="sessions">Sessions <small>each agent's own session, per task: what it said, read, ran and wrote</small></h2>${sessions || '<p class="none">no agent sessions in this run</p>'}` : "";
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Huddle run ${r.index}</title>
+<style>
+${STORY_CSS}${EXPORT_CSS}${filterRules(senders)}
+</style>
+</head>
+<body>
+<main id="top">
+<header class="hero">
+<div class="brand">⬢ HUDDLE · RUN ${r.index} OF ${r.of}</div>
+<h1>${esc(r.title || "(no goal)")}</h1>${r.goal.trim() !== r.title ? `<details><summary>The goal</summary><pre style="white-space:pre-wrap;word-break:break-word">${esc(r.goal)}</pre></details>` : ""}
+<div class="sub">${r.id ? esc(r.id) + " · " : ""}${esc(new Date(r.start).toLocaleString())} · ${esc(doc.agents.map((a) => a.id).join(", ") || "no agents")} · level ${esc(doc.level)}${doc.redacted ? ` · ${esc(plural(doc.redacted, "likely secret"))} redacted` : ""}</div>
+<div class="kpis">${kpis}</div>
+${res.qa ? `<p class="verdict ${res.qa.tone}">${res.qa.tone === "ok" ? "✓" : "!"} ${esc(plural(res.qaRounds, "QA round"))} · ${esc(res.qa.text)}</p>` : ""}
+</header>
+${crew ? `<div class="crew">${crew}</div>` : ""}
+<h2>Summary</h2>
+${tiles}
+<div class="cards summary">${plan}${decisions}${contract}${team}${cost}</div>
+${whoTable}
+${filter}
+${chat}
+${transcripts}
+<footer>made by huddle export · one file, no network</footer>
+</main>
+</body>
+</html>
+`;
+}
+const isCrew = (doc, a) => doc.agents.some((x) => x.id === a) && !NOT_AGENTS.has(a);
+/** One row per run: what `huddle runs` prints (and a dashboard can list). */
+export function runRows(runs) {
+    return runs.map((run) => {
+        const s = buildStory(run, runs.length);
+        const o = outcome(s);
+        return { index: run.index, id: run.id, start: run.start, ms: o.ms, goal: headline(run.goal, 120), agents: s.agents, merged: s.merged, failed: s.failed, tokens: o.tokens, merges: o.merges, green: o.green, qa: o.qa, qaRounds: o.rounds };
+    });
+}
+export function renderRuns(rows, width = 100) {
+    if (!rows.length)
+        return C.faint("  no runs yet in this repo — type a goal in `huddle` (or huddle join \"<goal>\") to start one.");
+    const out = [C.violet("RUNS") + C.faint(` · ${plural(rows.length, "run")} in this repo · newest last`), ""];
+    const w = Math.max(40, width - 8);
+    for (const r of rows) {
+        const goal = r.goal.length > w - 2 ? r.goal.slice(0, w - 3) + "…" : r.goal;
+        out.push(`  ${C.bold(String(r.index).padStart(3))}  ${C.bold(JSON.stringify(goal))}`);
+        const mark = r.failed ? C.yellow("◎") : r.merged ? C.green("✓") : C.faint("·");
+        const bits = [
+            new Date(r.start).toLocaleString(),
+            fmtDuration(r.ms),
+            r.agents.length ? r.agents.map((a) => `${dot(a)} ${a}`).join(" ") : "no agents",
+            `${mark} ${r.merged} merged${r.failed ? `, ${r.failed} failed` : ""}`,
+            r.merges ? `${r.green}/${r.merges} on green tests` : "",
+            r.qa ? r.qa.text.replace(/^QA\b\s*/, "QA ") : "",
+            r.tokens ? `${fmtTokens(r.tokens)} tok` : "",
+        ].filter(Boolean);
+        out.push(`       ${C.faint(bits.join(" · "))}`);
+    }
+    out.push("", C.faint(`  huddle export <#>  the run as a chat · huddle story --run <#>  its timeline`));
+    return out.join("\n");
+}
+async function openRuns() {
+    const { repoRoot, dbPath } = await import("./app.js");
+    const { isGitRepo } = await import("../sandbox/worktree.js");
+    const root = repoRoot();
+    if (!isGitRepo(root))
+        return { ok: false, why: "not-repo" };
+    if (!fs.existsSync(dbPath()))
+        return { ok: false, why: "no-room" };
+    const { RoomDB } = await import("../room/db.js");
+    const db = new RoomDB(dbPath());
+    try {
+        return { ok: true, runs: splitRuns(db.allEvents()), dbFile: dbPath(), root };
+    }
+    finally {
+        db.close();
+    }
+}
+function refuse(r, cmd) {
+    if (r.why === "not-repo") {
+        console.log(C.red("✗ Not a git repo.") + ` \`huddle ${cmd}\` reads the runs recorded in a repo's .huddle/ — cd into one first.`);
+        process.exitCode = 1;
+    }
+    else
+        console.log(C.faint("  no runs yet in this repo — type a goal in `huddle` (or huddle join \"<goal>\") to start one."));
+}
+/** `huddle runs` */
+export async function runRuns(_args) {
+    const r = await openRuns();
+    if (!r.ok)
+        return refuse(r, "runs");
+    console.log(renderRuns(runRows(r.runs), process.stdout.isTTY ? process.stdout.columns || 100 : 120));
+}
+/** "Build \"shelf\", a small app." → "build-shelf-a-small-app": at most 40 characters, cut between words. */
+const slug = (s) => {
+    const all = s
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^\w\s-]/g, "")
+        .trim()
+        .replace(/[\s_-]+/g, "-");
+    const cut = all.length > 40 ? all.slice(0, 41).replace(/-[^-]*$/, "") : all;
+    return cut.replace(/^-+|-+$/g, "") || "run";
+};
+/** `huddle export [<run>|latest] [--format md|html|json] [--out <path>] [--level summary|chat|full] [--no-redact]` */
+export async function runExport(args) {
+    const takes = new Set(["--format", "-f", "--out", "-o", "--level", "--run"]);
+    const flag = (...names) => {
+        for (const name of names) {
+            const i = args.indexOf(name);
+            if (i >= 0)
+                return args[i + 1] ?? "";
+            const eq = args.find((a) => a.startsWith(name + "="));
+            if (eq)
+                return eq.slice(name.length + 1);
+        }
+        return undefined;
+    };
+    const bad = (msg) => {
+        console.log(C.red("✗ " + msg));
+        process.exitCode = 1;
+    };
+    const positional = args.filter((a, i) => !a.startsWith("-") && !(i > 0 && takes.has(args[i - 1])));
+    const which = flag("--run") ?? positional[0];
+    const level = (flag("--level") ?? "chat");
+    if (!EXPORT_LEVELS.includes(level))
+        return bad(`--level is summary, chat or full (got ${JSON.stringify(level)})`);
+    const out = flag("--out", "-o");
+    if (out === "")
+        return bad("--out needs a path: huddle export --out run.md (or - for the terminal)");
+    const extFormat = out && out !== "-" ? { ".md": "md", ".markdown": "md", ".html": "html", ".htm": "html", ".json": "json" }[path.extname(out).toLowerCase()] : undefined;
+    const format = (flag("--format", "-f") ?? extFormat ?? "md");
+    if (!EXPORT_FORMATS.includes(format))
+        return bad(`--format is md, html or json (got ${JSON.stringify(format)})`);
+    const unknown = args.filter((a, i) => a.startsWith("-") && a !== "-" && !takes.has(a) && ![...takes].some((t) => a.startsWith(t + "=")) && a !== "--no-redact" && !(i > 0 && takes.has(args[i - 1])));
+    if (unknown.length)
+        return bad(`unknown option ${unknown[0]}. huddle export [<run>|latest] [--level summary|chat|full] [--format md|html|json] [--out <path>] [--no-redact]`);
+    const r = await openRuns();
+    if (!r.ok)
+        return refuse(r, "export");
+    if (!r.runs.length)
+        return refuse({ ok: false, why: "no-room" }, "export");
+    const run = findRun(r.runs, which);
+    if (!run)
+        return bad(`no run ${which}. \`huddle runs\` lists them (1–${r.runs.length}, or latest).`);
+    const huddle = path.dirname(r.dbFile);
+    const doc = buildExport(run, r.runs.length, { level, redact: !args.includes("--no-redact"), logsDir: path.join(huddle, "logs"), repoRoot: r.root });
+    const text = renderExport(doc, format);
+    if (out === "-")
+        return void process.stdout.write(text);
+    const name = `run-${run.index}-${slug(headline(run.goal))}${level === "chat" ? "" : "-" + level}.${format}`;
+    let file = out ? path.resolve(out) : path.join(huddle, "exports", name);
+    if (out && (out.endsWith("/") || out.endsWith(path.sep) || (fs.existsSync(file) && fs.statSync(file).isDirectory())))
+        file = path.join(file, name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text);
+    const sessions = Object.keys(doc.transcripts).length;
+    console.log(`${C.green("✓")} wrote ${file}` +
+        C.faint(` · run ${run.index} · ${level}${level !== "summary" ? ` · ${plural(doc.messages.length, "message")}` : ""}${level === "full" ? ` · ${plural(sessions, "session")}` : ""}${doc.redacted ? ` · ${plural(doc.redacted, "likely secret")} redacted (--no-redact keeps them)` : ""}`));
+}
+//# sourceMappingURL=export.js.map