huddle-cli 0.1.0 → 0.1.1

package/dist/ui/term.js

@@ -1,6 +1,41 @@
 // Terminal primitives: color, width-aware padding, the rounded box, spinners.
 // Huddle lives in the terminal only, so this file is the whole "UI toolkit".
 const color = process.stdout.isTTY && !process.env.NO_COLOR;
+/**
+ * A console that can't draw Huddle's glyphs: the old Windows console host
+ * (conhost: cmd.exe or PowerShell outside Windows Terminal) shows ⤳, ⇉,
+ * braille spinners and emoji as boxes or "?". HUDDLE_ASCII=1 forces plain
+ * ASCII anywhere; HUDDLE_ASCII=0 turns it off. Windows Terminal sets
+ * WT_SESSION, VS Code's terminal sets TERM_PROGRAM, ConEmu sets ConEmuANSI.
+ */
+export function legacyConsole(env = process.env, platform = process.platform) {
+    if (env.HUDDLE_ASCII === "1")
+        return true;
+    if (env.HUDDLE_ASCII === "0")
+        return false;
+    return platform === "win32" && !env.WT_SESSION && !env.TERM_PROGRAM && env.ConEmuANSI !== "ON";
+}
+export const ASCII = legacyConsole();
+const ASCII_MAP = {
+    "●": "*", "○": "o", "✓": "v", "✗": "x", "▸": ">", "◎": "@", "◆": "#", "◇": "#", "⚠": "!", "⇉": "=>", "⇢": "->",
+    "⤳": "~>", "⇄": "<>", "→": "->", "←": "<-", "↑": "^", "↓": "v", "…": "...", "·": "-", "—": "-", "–": "-", "“": '"', "”": '"',
+    "‘": "'", "’": "'", "─": "-", "━": "=", "│": "|", "╭": "+", "╮": "+", "╰": "+", "╯": "+", "┌": "+", "┐": "+", "└": "+", "┘": "+",
+    "█": "#", "░": ".", "▶": ">", "■": "#", "✎": "*", "⬢": "#", "⏱": "", "⚡": "!", "×": "x", "≥": ">=", "≤": "<=", "\uFE0F": "",
+};
+const ASCII_RE = new RegExp(`[${Object.keys(ASCII_MAP).join("")}]|[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}]\uFE0F?|\uFE0F|[\u2800-\u28FF]`, "gu");
+/** Huddle's glyphs → ASCII, for legacy consoles (escape codes pass through). */
+export function toAscii(s) {
+    return s.replace(ASCII_RE, (c) => ASCII_MAP[c] ?? ASCII_MAP[c.replace("\uFE0F", "")] ?? (c >= "\u2800" && c <= "\u28FF" ? "|" : "*"));
+}
+/** In a legacy console, every write to stdout/stderr goes through toAscii (once, at startup). */
+export function useAsciiOutput(on = ASCII) {
+    if (!on)
+        return;
+    for (const stream of [process.stdout, process.stderr]) {
+        const write = stream.write.bind(stream);
+        stream.write = (chunk, ...rest) => write(typeof chunk === "string" ? toAscii(chunk) : chunk, ...rest);
+    }
+}
 const sgr = (open) => (s) => (color ? `\x1b[${open}m${s}\x1b[0m` : s);
 const hex = (h) => {
     const n = parseInt(h.slice(1), 16);
@@ -33,9 +68,21 @@ export const AGENT_COLOR = {
 };
 /** Colored dot for an agent; "claude#2" gets Claude's color. */
 export const dot = (agentId) => hex(AGENT_COLOR[agentId.split("#")[0]] ?? "#8A857C")("●");
-/** Visible width of a string (ignores ANSI escapes). */
+/** Terminal cells for one character: emoji and CJK take two, combining marks none. */
+function cells(ch) {
+    const c = ch.codePointAt(0);
+    if (c === 0xfe0f || c === 0x200d || (c >= 0x300 && c <= 0x36f))
+        return 0;
+    if ((c >= 0x1f300 && c <= 0x1faff) || (c >= 0x1100 && c <= 0x115f) || (c >= 0x2e80 && c <= 0xa4cf) || (c >= 0xac00 && c <= 0xd7a3) || (c >= 0xf900 && c <= 0xfaff) || (c >= 0xff00 && c <= 0xff60))
+        return 2;
+    return 1;
+}
+/** Visible width of a string in terminal cells (ignores ANSI escapes). */
 export function width(s) {
-    return [...s.replace(/\x1b\[[0-9;]*m/g, "")].length;
+    let n = 0;
+    for (const ch of s.replace(/\x1b\[[0-9;]*m/g, ""))
+        n += cells(ch);
+    return n;
 }
 /** Cut to `n` visible characters, keeping color codes intact. */
 export function truncate(s, n) {
@@ -51,14 +98,42 @@ export function truncate(s, n) {
             continue;
         }
         const ch = String.fromCodePoint(s.codePointAt(i));
-        if (seen >= n - 1)
-            return out + "…\x1b[0m";
+        const w = cells(ch);
+        if (seen + w > n - 1)
+            return out + "…" + (out.includes("\x1b[") ? "\x1b[0m" : "");
         out += ch;
-        seen++;
+        seen += w;
         i += ch.length;
     }
     return out;
 }
+/** Word-wrap plain or colored text to `n` cells; `indent` starts every line after the first. */
+export function wrap(s, n, indent = "") {
+    const lead = /^ */.exec(s)[0];
+    if (!indent.startsWith(lead))
+        indent = lead + indent;
+    const out = [];
+    let line = lead;
+    for (const word of s.slice(lead.length).split(/ +/)) {
+        if (line.trim() && width(line) + 1 + width(word) > n) {
+            out.push(line);
+            line = indent + word;
+        }
+        else
+            line = line.trim() ? line + " " + word : line + word;
+    }
+    out.push(line);
+    return out.map((l) => truncate(l, n + 1));
+}
+/** Columns to fit printed lines to: the terminal's (minus one, so nothing auto-wraps), or none when piped. */
+export function lineWidth(out = process.stdout) {
+    return out.isTTY ? Math.max(20, (out.columns || 80) - 1) : null;
+}
+/** One printed line, cut to the terminal (no-op when piped: logs keep everything). */
+export function fit(s, out = process.stdout) {
+    const w = lineWidth(out);
+    return w === null ? s : s.split("\n").map((l) => truncate(l, w)).join("\n");
+}
 export function pad(s, n) {
     return s + " ".repeat(Math.max(0, n - width(s)));
 }
@@ -71,44 +146,104 @@ export function box(lines, opts = {}) {
     const mid = lines.map((l) => border("│") + " " + pad(l, inner - 2) + " " + border("│"));
     return [top, ...mid, bot].join("\n");
 }
-const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-/** A set of lines that re-render in place while async work settles. */
+const FRAMES = ASCII ? ["|", "/", "-", "\\"] : ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * A set of lines that re-render in place while async work settles. Each row
+ * is cut to the terminal's width: a row that wraps takes two screen lines,
+ * so moving the cursor up "one per row" would land mid-list and every redraw
+ * would print the list again further down (seen on Windows: rows doubled and
+ * spliced, "API_KEYodex · openai").
+ */
 export class LiveLines {
     render;
+    out;
     lines;
     frame = 0;
     timer;
     drawn = false;
-    constructor(render) {
+    constructor(render, out = process.stdout) {
         this.render = render;
+        this.out = out;
         this.lines = [];
     }
     start() {
         this.draw();
-        if (process.stdout.isTTY)
+        if (this.out.isTTY)
             this.timer = setInterval(() => this.draw(), 80);
         return this;
     }
+    /** One screen line per row: never wider than the terminal (minus one, so no auto-wrap). */
+    fit(l) {
+        return truncate(l.replace(/[\r\n]+/g, " "), Math.max(10, (this.out.columns || 80) - 1));
+    }
     draw() {
-        if (!process.stdout.isTTY)
+        if (!this.out.isTTY)
             return; // non-TTY: draw once at stop()
-        const next = this.render(C.violet(FRAMES[this.frame++ % FRAMES.length]));
-        if (this.drawn)
-            process.stdout.write(`\x1b[${this.lines.length}A`);
+        const next = this.render(C.violet(FRAMES[this.frame++ % FRAMES.length])).map((l) => this.fit(l));
+        let s = this.drawn && this.lines.length ? `\x1b[${this.lines.length}A` : "";
         for (const l of next)
-            process.stdout.write("\x1b[2K" + l + "\n");
+            s += "\x1b[2K" + l + "\n";
+        this.out.write(s); // one write: no half-drawn frame
         this.lines = next;
         this.drawn = true;
     }
     stop() {
         if (this.timer)
             clearInterval(this.timer);
-        if (!process.stdout.isTTY) {
+        if (!this.out.isTTY) {
             for (const l of this.render(" "))
-                process.stdout.write(l + "\n");
+                this.out.write(l + "\n");
             return;
         }
         this.draw();
     }
 }
+/**
+ * Lines pinned under scrolling output — the run's status block. log() prints
+ * a line above them and redraws them; nothing else should write to `out`
+ * while the dock is up. TTY only: piped output (a log file) gets the logged
+ * lines and never the dock.
+ */
+export class Dock {
+    render;
+    out;
+    n = 0;
+    timer;
+    up = false;
+    constructor(render, out = process.stdout) {
+        this.render = render;
+        this.out = out;
+    }
+    paint() {
+        const w = Math.max(10, (this.out.columns || 80) - 1);
+        const ls = this.render().map((l) => truncate(l.replace(/[\r\n]+/g, " "), w));
+        this.n = ls.length;
+        return ls.map((l) => "\x1b[2K" + l + "\n").join("");
+    }
+    clear() {
+        return this.n ? `\x1b[${this.n}A\x1b[J` : "";
+    }
+    start() {
+        if (!this.out.isTTY || this.up)
+            return this;
+        this.up = true;
+        this.out.write(this.paint());
+        this.timer = setInterval(() => this.out.write(this.clear() + this.paint()), 1000);
+        this.timer.unref?.();
+        return this;
+    }
+    log(line) {
+        if (!this.up)
+            return void this.out.write(line + "\n");
+        this.out.write(this.clear() + line + "\n" + this.paint());
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.up)
+            this.out.write(this.clear());
+        this.up = false;
+        this.n = 0;
+    }
+}
 //# sourceMappingURL=term.js.map

package/dist/ui/watch.js

@@ -23,47 +23,111 @@ const json = (s) => {
 const clip = (s, n = 160) => String(s ?? "").replace(/\s+/g, " ").trim().slice(0, n);
 /** Writers in the room that aren't agents — no pane of their own. */
 const ROOM_AUTHORS = new Set(["council", "huddle", "brain", "qa"]);
-/** One persisted event → a line for an agent's pane (agent set) or the room strip. */
+/**
+ * One persisted event → a line for an agent's pane (agent set) or the room strip.
+ * The same words and glyphs as the run's own output: ▸ start, ✓ done, ✗ failed or
+ * a bug, ◎ a review or buddy check, ◆ the contract or memory, ⚠ radar, ⇉ a pair.
+ */
 export function activityOf(e) {
     const p = json(e.payload);
     const who = e.agent_id ?? p.agent;
     switch (e.type) {
         case "run.start":
-            return { agent: who, text: `▸ ${clip(p.title)}` };
+            return { agent: who, text: `${C.violet("▸")} ${clip(p.title)}` };
         case "task.progress":
             // Progress rows carry the task, not always the agent; runView resolves the owner.
             if (!clip(p.note))
                 return null;
-            return { agent: who, text: `${p.pct}%  ${clip(p.note)}` };
+            return { agent: who, text: `${C.faint(`${p.pct}%`)}  ${clip(p.note)}` };
         case "plan.announced":
-            return { agent: who, text: `plans: ${clip(p.summary ?? p.plan ?? p.intent ?? p.title)}` };
+            return { agent: who, text: `${C.faint("plans:")} ${clip(p.summary ?? p.plan ?? p.intent ?? p.title)}` };
         case "run.review":
-            return { agent: who, text: `◎ reviewing ${p.author}'s “${clip(p.title, 60)}”` };
+            return { agent: who, text: `${C.violet("◎")} reviewing ${p.author}'s “${clip(p.title, 60)}”` };
         case "run.reviewed":
-            return { agent: who, text: p.skipped ? `review skipped (${clip(p.notes, 40)})` : p.approve ? `✓ approved ${p.author}'s work` : `✗ asked ${p.author} for changes: ${clip(p.notes)}` };
+            return {
+                agent: who,
+                text: p.skipped
+                    ? C.faint(`review skipped (${clip(p.notes, 40)})`)
+                    : p.approve
+                        ? `${C.green("✓ approved")} ${p.author}'s work`
+                        : `${C.yellow("✎ asked")} ${p.author} for changes: ${clip(p.notes)}`,
+            };
         case "run.merged":
-            return { agent: who, text: `✓ merged ${clip(p.title, 80)}` };
+            return { agent: who, text: `${C.green("✓ merged")} ${clip(p.title, 80)}` };
         case "run.failed":
-            return { agent: who, text: `✗ failed ${clip(p.title, 60)} — ${clip(p.reason ?? p.error, 80)}` };
-        case "agent.message":
+            return { agent: who, text: `${C.red("✗ failed")} ${clip(p.title, 60)} — ${clip(p.reason ?? p.error, 80)}` };
+        case "agent.message": {
+            // Huddle relaying a buddy check: say it as the teammate's note it is.
+            const b = /^buddy check from (\S+) (?:at )?([^:\n]*):\s*([\s\S]*)$/i.exec(String(p.body ?? ""));
+            if (p.from === "huddle" && b)
+                return { text: `${C.violet("◎")} ${b[1]} → ${p.to} ${C.faint(`(buddy note, ${b[2].trim()})`)}: ${clip(b[3])}` };
             return { text: `${p.from} → ${p.to}: ${clip(p.body)}` };
-        case "memory.added":
-            return { text: `◆ ${p.author ?? who ?? "memory"}: ${clip(p.body)}` };
+        }
+        case "memory.added": {
+            const body = String(p.body ?? "");
+            // Each of these is already its own line: a merged task, a QA bug, a message.
+            if (/^Task \S+ done:|^QA \(\S+\) found:|^\S+ → \S+:/.test(body))
+                return null;
+            const author = p.author ?? who ?? "memory";
+            const risk = /^council risk(?: \(\w+\))?:\s*/i.exec(body);
+            if (risk)
+                return { text: `${C.yellow("!")} ${author} risk: ${clip(body.slice(risk[0].length))}` };
+            return { text: `${C.violet("◆")} ${author}: ${clip(body.replace(new RegExp(`^${author}:\\s*`), ""))}` };
+        }
         case "council.proposal":
-            return { agent: who, text: `proposes: ${clip(p.text)}` };
+            return { agent: who, text: `${C.faint("proposes:")} ${clip(p.text)}` };
         case "council.critique":
-            return { agent: who, text: `flags: ${clip(p.text)}` };
+            return { agent: who, text: `${C.faint("flags:")} ${clip(p.text)}` };
+        case "council.adopt":
+            return { agent: who, text: `${C.green("+ adopts")} ${p.of}'s idea: ${clip(p.body)}` };
+        case "council.flaw":
+            return { agent: who, text: `${C.yellow("! flaw in")} ${p.of}'s idea: ${clip(p.body)}` };
+        case "council.ratify":
+            return {
+                agent: who,
+                text: p.verdict === "object" ? `${C.yellow("objects")} to the contract: ${clip((p.objections ?? []).join(" · "))}` : `${C.green("✓ ratifies")} the contract`,
+            };
         case "council.plan":
-            return { text: `◇ council plan ready` };
+            return { text: `${C.violet("◇")} council plan ready${p.synthesizer?.id ? ` · written by ${p.synthesizer.id}` : ""}` };
+        case "contract.set":
+            return p.text ? { text: `${C.violet("◆")} contract v1 by ${p.by ?? "council"} · the names every task codes to` } : null;
+        case "contract.amended":
+            return { text: `${C.violet("◆")} contract v${p.version} by ${p.by}: ${clip(`${p.section}: ${p.change}`)}` };
+        case "run.radar":
+            return { agent: who, text: `${C.yellow("⚠ radar:")} ${p.kind === "overlap" ? "overlap" : "name mismatch"} with ${p.with} · ${clip(p.detail)}` };
+        case "run.checkpoint": {
+            const ok = /^LOOKS GOOD/i.test(String(p.notes ?? "").trim());
+            return {
+                agent: who,
+                text: `${C.violet("◎")} buddy check on ${p.author}'s work ${p.pct ? `at ${p.pct}%` : "mid-task"}: ${ok ? C.green("looks good") : `${p.late ? "(came back after it landed) " : ""}${clip(p.notes)}`}`,
+            };
+        }
+        case "note.closed":
+            return {
+                agent: p.to ?? who,
+                text: `${C.violet("◎")} ${p.kind === "radar" ? "radar finding" : `${p.by}'s buddy note`} ${p.how === "ignored" ? C.yellow("ignored") : C.green(p.how === "replied" ? "answered" : "addressed in code")}: ${clip(p.body, 100)}`,
+            };
+        case "run.pair":
+            return { agent: who, text: `${C.violet("⇉")} pairs with ${p.with} on “${clip(p.title, 60)}”: ${clip(p.part, 80)}` };
         case "qa.round":
-            return { text: `◎ QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
+            return { text: `${C.violet("◎")} QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
         case "qa.bug":
-            return { text: `🐞 ${who ?? "QA"} found: ${clip(p.title ?? p.body)}` };
+            return { text: `${C.yellow("✗")} ${who ?? "QA"} found a bug: ${clip(p.title ?? p.body)}` };
+        case "qa.done":
+            return { agent: who, text: p.ok ? `${C.green("✓ QA done")} · ${p.bugs ?? 0} bug(s) filed` : C.yellow("! QA didn't finish") };
         case "qa.clean":
-            return { text: `✓ QA round ${p.round ?? ""} clean` };
+            return { text: `${C.green("✓")} QA round ${p.round ?? ""} clean` };
+        case "qa.suspect":
+            return { text: `${C.yellow("?")} QA round ${p.round ?? ""} clean, but quick: a second agent checks` };
+        case "context.added":
+            return { text: `${C.violet("+")} ${p.by ?? "you"} put ${p.id} on the screen: “${clip(p.title, 60)}”` };
+        case "context.note":
+            return { text: `${C.violet("◆")} ${p.by ?? who} on ${p.id}: ${clip(p.body)}` };
+        case "context.read":
+            return who ? { agent: who, text: `${C.faint("read")} ${p.id} “${clip(p.title, 50)}”${p.from ? ` lines ${p.from}-${p.to}` : ""}` } : null;
         default:
             if (e.type.startsWith("takeover") || e.type === "run.takeover")
-                return { text: `⇄ ${p.to ?? who} took over ${p.from}'s “${clip(p.title, 60)}” (${clip(p.reason, 40)})` };
+                return { text: `${C.yellow("⤳")} ${p.to ?? who} took over ${p.from}'s “${clip(p.title, 60)}” (${clip(p.reason, 40)})` };
             return null;
     }
 }
@@ -86,12 +150,21 @@ export function statsOf(db, events) {
             get(a.id);
     for (const e of run) {
         const p = json(e.payload);
+        // A QA round: its checkers are busy until each one's qa.done.
+        if (e.type === "qa.round")
+            for (const q of (p.agents ?? []))
+                if (!ROOM_AUTHORS.has(q))
+                    get(q).busySince = e.ts;
         const id = e.agent_id ?? p.agent;
         if (!id || ROOM_AUTHORS.has(id))
             continue;
         const a = get(id);
         if (e.type === "run.start" || e.type === "run.review")
             a.busySince = e.ts;
+        else if (e.type === "qa.done") {
+            a.busySince = null;
+            a.qa = (a.qa ?? 0) + 1;
+        }
         else if (e.type === "run.merged" || e.type === "run.failed" || e.type === "run.reviewed") {
             a.busySince = null;
             if (e.type === "run.merged")
@@ -101,37 +174,39 @@ export function statsOf(db, events) {
             a.tokens += Number(p.tokens) || 0;
         }
     }
-    return { startedAt: starts[0]?.ts ?? since, agents };
+    // Over: nobody busy and every task landed or failed. The clock stops at the last event.
+    const busy = [...agents.values()].some((a) => a.busySince);
+    const tasks = db.listTasks();
+    const over = !busy && tasks.length > 0 && tasks.every((t) => t.status === "merged" || t.status === "failed");
+    return { startedAt: starts[0]?.ts ?? since, ...(over && run.length ? { endedAt: run[run.length - 1].ts } : {}), agents };
 }
-function repoRoot(dir) {
-    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8" });
-    return r.status === 0 ? r.stdout.trim() : dir;
-}
-export async function runView(args) {
-    const root = repoRoot(path.resolve(args.find((a) => !a.startsWith("-")) ?? process.cwd()));
-    const file = path.join(root, ".huddle", "huddle.db");
-    if (!fs.existsSync(file)) {
-        console.log(C.red("✗ No Huddle room here yet.") + ` Start a run in ${root} (huddle, or huddle join "<goal>"), then run huddle view.`);
-        process.exit(1);
-    }
-    if (!process.stdout.isTTY || !process.stdin.isTTY) {
-        console.log(C.red("✗ huddle view needs a terminal.") + " For a plain-text replay use: huddle story");
-        process.exit(1);
-    }
-    const db = new RoomDB(file);
-    let events = db.allEvents();
-    let stats = statsOf(db, events);
+/**
+ * The read-only view on a Room db: the dashboard, fed this run's events so
+ * far. refresh() picks up what another process wrote since. (runView polls
+ * it; the samples and tests call frame() on it directly.)
+ */
+export function viewOf(db) {
+    let events = [];
+    let stats = null;
     const dash = new Dashboard({
         db: () => db,
         stats: () => stats,
         modeChip: () => C.faint("watching · read-only"),
         hint: "1 2 3 switch · q close the view (agents keep working)",
+        empty: "waiting for a run — agents show up here as they pick up tasks",
     });
-    // Replay this run's feed so the panes aren't empty when you open late.
-    const since = db.currentSession()?.created_at ?? 0;
     let seen = 0; // events come back ordered by (ts, rowid), so new ones are a suffix
-    const feed = (list) => {
-        for (const e of list.slice(seen)) {
+    let since = -1;
+    const refresh = () => {
+        events = db.allEvents();
+        stats = statsOf(db, events);
+        // A new run (a new session) starts the panes over.
+        const s = db.currentSession()?.created_at ?? 0;
+        if (s !== since) {
+            since = s;
+            seen = 0;
+        }
+        for (const e of events.slice(seen)) {
             if (e.ts < since)
                 continue;
             const a = activityOf(e);
@@ -143,14 +218,36 @@ export async function runView(args) {
             if (a)
                 dash.push(a);
         }
-        seen = list.length;
+        seen = events.length;
     };
-    feed(events);
-    const poll = setInterval(() => {
-        events = db.allEvents();
-        stats = statsOf(db, events);
-        feed(events);
-    }, 1000);
+    refresh();
+    return { dash, refresh };
+}
+function repoRoot(dir) {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8" });
+    return r.status === 0 ? r.stdout.trim() : dir;
+}
+export async function runView(args) {
+    const root = repoRoot(path.resolve(args.find((a) => !a.startsWith("-")) ?? process.cwd()));
+    const file = path.join(root, ".huddle", "huddle.db");
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        if (!fs.existsSync(file))
+            console.log(C.red("✗ No Huddle room here yet.") + ` Start a run in ${root} (huddle, or huddle join "<goal>"), then run huddle view.`);
+        else
+            console.log(C.red("✗ huddle view needs a terminal.") + " For a plain-text replay use: huddle story");
+        process.exit(1);
+    }
+    // Opened before the first run here: wait for its room instead of giving up.
+    if (!fs.existsSync(file)) {
+        console.log(`${C.faint("○")} No room in ${root} yet. ${C.faint('Waiting for a run to start here (huddle, or huddle join "<goal>") · ctrl-c to stop')}`);
+        await new Promise((resolve) => {
+            const t = setInterval(() => fs.existsSync(file) && (clearInterval(t), resolve()), 1000);
+        });
+    }
+    const db = new RoomDB(file);
+    // Replay this run's feed so the panes aren't empty when you open late.
+    const { dash, refresh } = viewOf(db);
+    const poll = setInterval(refresh, 1000);
     readline.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     await new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huddle-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The multiplayer layer for AI coding agents. One command. Every agent. One repo. Zero collisions.",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
   "files": [
     "dist/**/*.js",
     "install.sh",
+    "QUICKSTART.md",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
@@ -30,8 +32,9 @@
     "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit",
     "prepare": "npm run build",
     "prepublishOnly": "npm run typecheck && npm test",
-    "test": "rm -rf .test-build && tsc -p tsconfig.test.json && HUDDLE_NO_AGENTS_FILE=1 node --test --test-concurrency=1 .test-build/test/*.test.js",
-    "e2e": "npm run build && rm -rf .test-build && tsc -p tsconfig.test.json && node .test-build/test/e2e/run.js"
+    "test": "node scripts/test.mjs",
+    "e2e": "npm run build && node scripts/test.mjs e2e",
+    "evolve": "npm run build && node scripts/test.mjs evolve"
   },
   "keywords": [
     "ai",