huddle-cli 0.0.0-stage → 0.1.0

package/dist/ui/app.js

@@ -0,0 +1,1534 @@
+// The Huddle app: what you get when you type `huddle`.
+//
+//   ╭──────────────────────────────────────────╮
+//   │ (logo)  Welcome to Huddle                │
+//   │         try  join "<goal>" · agents · help│
+//   │         cwd  ~/shop                      │
+//   ╰──────────────────────────────────────────╯
+//   Connecting your agents…
+//   huddle › _
+//
+// Everything happens here. Claude, Codex, Gemini and Cursor run in the
+// background as Huddle's workers; you watch the board, never their terminals.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+import { ADAPTERS, probeAsync } from "../adapters/index.js";
+import { RoomDB } from "../room/db.js";
+import { startRoom } from "../room/server.js";
+import { openFunnel, openTunnel, tailscaleIp } from "../room/tunnel.js";
+import { openRelayLink } from "../room/relaylink.js";
+import { canonicalRemote, pullLatest, pushMerged, readRepoConfig, remoteInfo, writeRepoConfig } from "../sandbox/sync.js";
+import { githubRepo, githubUser, isCollaborator } from "../room/identity.js";
+import { isBigGoal, listsOwnTasks, planGoal, seedBoard } from "../orchestrator/planner.js";
+import { councilMembers, councilWanted, headline, recordCouncil, runCouncil } from "../orchestrator/council.js";
+import { pickAsker } from "../orchestrator/ask.js";
+import { brainFrom, brainOptions, ollamaModels } from "../orchestrator/brain.js";
+import { fmtDuration, fmtTokens } from "../adapters/usage.js";
+import { runBoard } from "../orchestrator/scheduler.js";
+import { runQa, shouldQa } from "../orchestrator/qa.js";
+import { isGitRepo, listWorktrees, removeWorktree, worktreeFor } from "../sandbox/worktree.js";
+import { C, LiveLines, box, dot, pad, truncate } from "./term.js";
+import { AGENTS_FILE_ERRORS, LEGACY } from "../adapters/index.js";
+import { logoLines } from "./logo.js";
+import { Dashboard } from "./dashboard.js";
+// 0 = pick a free port per run, so sessions never collide.
+export const ROOM_PORT = Number(process.env.HUDDLE_ROOM_PORT ?? 0);
+// ---- paths & repo ----------------------------------------------------------
+export function repoRoot() {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+    return r.status === 0 ? r.stdout.trim() : process.cwd();
+}
+export const huddleDir = () => path.join(repoRoot(), ".huddle");
+export const dbPath = () => path.join(huddleDir(), "huddle.db");
+/** Create .huddle/ + the Room db. Idempotent. Returns false if not a git repo. */
+export function ensureInit() {
+    const root = repoRoot();
+    if (!isGitRepo(root))
+        return false;
+    fs.mkdirSync(huddleDir(), { recursive: true });
+    // keep worktrees, logs & db out of the user's commits
+    fs.writeFileSync(path.join(huddleDir(), ".gitignore"), "*\n");
+    new RoomDB(dbPath()).close();
+    return true;
+}
+/** The repo's test command, if we can find one. The merge engine's referee. */
+export function detectTestCmd(root) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+        const t = pkg.scripts?.test;
+        if (t && !/no test specified/.test(t))
+            return "npm test --silent";
+    }
+    catch {
+        /* no package.json */
+    }
+    if (fs.existsSync(path.join(root, "Makefile")) && /^test:/m.test(fs.readFileSync(path.join(root, "Makefile"), "utf8")))
+        return "make test";
+    if (fs.existsSync(path.join(root, "Cargo.toml")))
+        return "cargo test";
+    if (fs.existsSync(path.join(root, "go.mod")))
+        return "go test ./...";
+    if (fs.existsSync(path.join(root, "pyproject.toml")) || fs.existsSync(path.join(root, "pytest.ini")))
+        return "pytest -q";
+    // Plain node:test files with no package.json — Node's built-in runner finds them.
+    const files = spawnSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: root, encoding: "utf8" }).stdout ?? "";
+    if (/(^|\/)[^/]+\.test\.(c|m)?js$|(^|\/)test\/[^/]+\.(c|m)?js$/m.test(files))
+        return "node --test";
+    return null;
+}
+/**
+ * The brain to use: your pick if it's usable, else Sonnet (fast, strong plans,
+ * a fraction of Opus's tokens), else whichever agent can answer read-only.
+ */
+export function resolveBrain(results, probed = results) {
+    const ready = results.filter((r) => r.state === "ready").map((r) => r.adapter.id);
+    const want = readPrefs().brain;
+    if (want) {
+        const kind = want.split(":")[0];
+        const b = brainFrom(want);
+        // Your explicit brain pick holds even when --agents leaves that CLI off this
+        // run's roster: the brain plans and reports, it doesn't take tasks.
+        if (b && (kind === "ollama" || probed.some((r) => r.state === "ready" && r.adapter.id === kind)))
+            return b;
+    }
+    if (ready.includes("claude"))
+        return brainFrom("claude:sonnet");
+    const asker = pickAsker(results.filter((r) => r.state === "ready").map((r) => r.adapter));
+    return asker ? brainFrom(asker.id) : null;
+}
+// HUDDLE_HOME lets two Huddle identities share one machine (tests, demos).
+const PREFS = path.join(process.env.HUDDLE_HOME ?? path.join(os.homedir(), ".huddle"), "prefs.json");
+export function readPrefs() {
+    try {
+        return JSON.parse(fs.readFileSync(PREFS, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writePrefs(p) {
+    fs.mkdirSync(path.dirname(PREFS), { recursive: true });
+    fs.writeFileSync(PREFS, JSON.stringify(p, null, 2));
+}
+// ---- welcome ---------------------------------------------------------------
+function tildify(p) {
+    const h = os.homedir();
+    return p.startsWith(h) ? "~" + p.slice(h.length) : p;
+}
+/** First line of a note, capped — the full text lives in `board`. */
+function oneLine(s, n) {
+    const l = s.replace(/\s+/g, " ").trim();
+    return l.length <= n ? l : l.slice(0, n - 1) + "…";
+}
+/** Keep the end of a long path: "…/scratchpad/demo". */
+function clip(s, n) {
+    return s.length <= n ? s : "…" + s.slice(s.length - n + 1);
+}
+export function printWelcome(gitOk) {
+    const logo = logoLines();
+    const text = [
+        "",
+        "",
+        C.bold("Welcome to Huddle"),
+        C.faint(`try  <a goal>  ·  <a question>?  ·  help`),
+        C.faint(`cwd  ${clip(tildify(process.cwd()), 48)}`),
+        gitOk
+            ? ""
+            : childRepos().length === 1
+                ? C.faint(`project repo found in ${childRepos()[0]}/`)
+                : C.faint("not a git repo yet — Huddle will set it up when you give it a goal"),
+    ];
+    const cols = Math.min(process.stdout.columns || 80, 84);
+    const lines = logo.map((l, i) => ` ${C.bold(l)}    ${text[i] ?? ""}`);
+    console.log(box(lines, { width: cols - 4 }));
+}
+// ---- agents: connect, install, sign in ----------------------------------------
+const PROVIDER = {
+    claude: "anthropic",
+    codex: "openai",
+    antigravity: "google",
+    gemini: "google",
+    cursor: "cursor",
+};
+/** Probe every adapter in parallel with a live, in-place status list. */
+export async function connectAgents() {
+    console.log("\nConnecting your agents…");
+    const results = new Map();
+    const shown = (a) => !LEGACY.has(a.id) || results.get(a.id)?.state === "ready";
+    const row = (a, spin) => {
+        const r = results.get(a.id);
+        const head = `${pad(dot(a.id) + " " + C.bold(a.id), 14)}  ${pad(C.faint("· " + (PROVIDER[a.id] ?? a.vendor)), 12)}`;
+        if (!r)
+            return `  ${spin} ${head}  ${C.faint("connecting…")}`;
+        if (r.state === "ready")
+            return `  ${C.green("✓")} ${head}  ready`;
+        if (r.state === "not_installed")
+            return `  ${C.faint("○")} ${head}  ${C.faint("not installed")}`;
+        return `  ${C.yellow("!")} ${head}  ${C.yellow("not signed in")} ${C.faint("— " + r.detail)}`;
+    };
+    // Probe legacy CLIs first (silently) so they only appear when installed.
+    for (const a of ADAPTERS.filter((a) => LEGACY.has(a.id)))
+        results.set(a.id, await probeAsync(a));
+    const visible = ADAPTERS.filter(shown);
+    const live = new LiveLines((spin) => visible.map((a) => row(a, spin))).start();
+    await Promise.all(visible.map(async (a) => {
+        if (!results.has(a.id))
+            results.set(a.id, await probeAsync(a));
+        live.draw();
+    }));
+    live.stop();
+    // Connectors declared in agents.json: say where they came from, and what's wrong with any that didn't load.
+    for (const a of visible.filter((a) => a.source))
+        console.log(C.faint(`  ${a.id} is declared in ${a.source.replace(os.homedir(), "~")}`));
+    for (const e of AGENTS_FILE_ERRORS)
+        console.log(`  ${C.yellow("!")} ${C.faint(e)}`);
+    return visible.map((a) => results.get(a.id));
+}
+/** Hooks the live prompt installs so y/n questions don't collide with output. */
+const questionHooks = { before: () => { }, after: () => { } };
+async function yes(rl, q, def = true) {
+    questionHooks.before();
+    try {
+        const a = (await rl.question(`${q} ${C.faint(def ? "[Y/n]" : "[y/N]")} `)).trim().toLowerCase();
+        return a === "" ? def : a.startsWith("y");
+    }
+    finally {
+        questionHooks.after();
+    }
+}
+/** Run a shell command with the terminal handed over (installers, logins). */
+function runInteractive(rl, cmd) {
+    rl.pause();
+    const r = typeof cmd === "string"
+        ? spawnSync("sh", ["-c", cmd], { stdio: "inherit" })
+        : spawnSync(cmd[0], cmd.slice(1), { stdio: "inherit" });
+    rl.resume();
+    return r.status === 0;
+}
+/**
+ * Offer to install missing agents and sign in to logged-out ones — always with
+ * the user's OK. A "no" is remembered so we don't nag on every launch; the
+ * `agents` command asks again.
+ */
+export async function offerSetup(rl, results, force = false) {
+    const prefs = readPrefs();
+    const declined = new Set(force ? [] : (prefs.declinedInstall ?? []));
+    const missing = results.filter((r) => r.state === "not_installed" && !declined.has(r.adapter.id) && !LEGACY.has(r.adapter.id));
+    const loggedOut = results.filter((r) => r.state === "not_authed" && !declined.has(r.adapter.id));
+    let changed = false;
+    if (missing.length) {
+        console.log();
+        for (const r of missing)
+            console.log(`  ${dot(r.adapter.id)} ${C.bold(r.adapter.id)}  ${C.faint("$ " + r.adapter.install.cmd)}`);
+        const names = missing.map((r) => r.adapter.id).join(", ");
+        if (await yes(rl, `\nInstall ${names}?`)) {
+            for (const r of missing) {
+                console.log(C.violet(`\n↓ installing ${r.adapter.id}…`));
+                const ok = runInteractive(rl, r.adapter.install.cmd);
+                console.log(ok ? C.green(`✓ ${r.adapter.id} installed`) : C.red(`✗ ${r.adapter.id} install failed — see output above`));
+                changed ||= ok;
+                if (ok && r.adapter.install.login && (await yes(rl, `Sign in to ${r.adapter.id} now?`))) {
+                    if (r.adapter.install.loginNote)
+                        console.log(C.faint(`  ${r.adapter.install.loginNote}`));
+                    runInteractive(rl, r.adapter.install.login);
+                }
+            }
+        }
+        else {
+            writePrefs({ ...prefs, declinedInstall: [...new Set([...(prefs.declinedInstall ?? []), ...missing.map((r) => r.adapter.id)])] });
+            console.log(C.faint("  ok — type `agents` any time to set them up."));
+        }
+    }
+    for (const r of loggedOut) {
+        const login = r.adapter.install.login;
+        if (!login)
+            continue;
+        if (await yes(rl, `\n${r.adapter.id} isn't signed in. Sign in now?`)) {
+            if (r.adapter.install.loginNote)
+                console.log(C.faint(`  ${r.adapter.install.loginNote}`));
+            runInteractive(rl, login);
+            changed = true;
+        }
+        else {
+            const p = readPrefs();
+            writePrefs({ ...p, declinedInstall: [...new Set([...(p.declinedInstall ?? []), r.adapter.id])] });
+        }
+    }
+    return changed;
+}
+export function newStats(workers) {
+    return {
+        startedAt: Date.now(),
+        agents: new Map(workers.map((w) => [w, { busySince: null, liveTokens: 0, tokens: 0, cached: 0, ms: 0, tasks: 0, reviews: 0 }])),
+    };
+}
+/** Ready agents × crew counts → workers: claude, claude#2, codex, … */
+const prefersOf = (w) => w.adapter?.prefers ?? w.remote?.prefers ?? [];
+export function workersFrom(results) {
+    const crew = readPrefs().crew ?? {};
+    const out = [];
+    for (const r of results.filter((r) => r.state === "ready")) {
+        const n = crew[r.adapter.id] ?? 1;
+        for (let i = 1; i <= n; i++)
+            out.push({ id: i === 1 ? r.adapter.id : `${r.adapter.id}#${i}`, adapter: r.adapter });
+    }
+    return out;
+}
+function git(args, cwd = process.cwd()) {
+    const r = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return { ok: r.status === 0, out: (r.stdout ?? "").trim() };
+}
+const DEFAULT_GITIGNORE = "node_modules/\n.env\n.env.*\n.DS_Store\n__pycache__/\n.venv/\ndist/\nbuild/\n";
+/** Git repos one level down — e.g. ~/Loomin/LoominPhysicsSandbox/.git. */
+function childRepos(dir = process.cwd()) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && !d.name.startsWith(".") && fs.existsSync(path.join(dir, d.name, ".git")))
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * You're in a folder that isn't a repo, but the project repo is inside it.
+ * Offer to move there instead of creating a repo around another repo.
+ * Returns true if we switched.
+ */
+async function offerChildRepo(print, rl) {
+    if (isGitRepo(process.cwd()))
+        return false;
+    const kids = childRepos();
+    if (kids.length === 1) {
+        print(C.yellow(`\n  The project's git repo is in ${kids[0]}/`) + C.faint(" — this folder is just around it."));
+        if (await yes(rl, `  Switch to ${kids[0]}/?`)) {
+            process.chdir(path.join(process.cwd(), kids[0]));
+            ensureInit();
+            print(`  ${C.faint("cwd")} ${tildify(process.cwd())}`);
+            return true;
+        }
+    }
+    else if (kids.length > 1) {
+        print(C.yellow(`\n  This folder holds ${kids.length} git repos: `) + kids.map((k) => C.bold(k)).join(", ") + C.faint(" — `cd` into the one you want."));
+    }
+    return false;
+}
+/**
+ * Make sure agents can work here: a git repo with everything committed.
+ * Agents branch off the last commit, so uncommitted work would be invisible
+ * to them. Always asks first; returns false if we can't proceed.
+ */
+async function prepareRepo(print, rl, goal = "") {
+    if (!isGitRepo(process.cwd()) && childRepos().length) {
+        // Never wrap an existing repo in a new one.
+        if (!rl || !(await offerChildRepo(print, rl))) {
+            if (!rl)
+                print(C.red("✗ Not a git repo.") + ` The project is in: ${childRepos().join(", ")} — cd there.`);
+            return false;
+        }
+    }
+    if (!isGitRepo(process.cwd())) {
+        if (!rl) {
+            print(C.red("✗ Not a git repo.") + " Run `git init` and commit your files first — or run `huddle` here and it sets the repo up (asks first).");
+            return false;
+        }
+        print(C.yellow("\n  This folder isn't a git repo yet.") + C.faint(" Huddle gives each agent its own copy through git."));
+        if (!(await yes(rl, "  Set it up? (git init + commit your current files)")))
+            return false;
+        if (spawnSync("git", ["--version"]).status !== 0) {
+            print(C.red("  ✗ git isn't installed.") + C.faint(" macOS: xcode-select --install · Linux: your package manager · https://git-scm.com"));
+            return false;
+        }
+        const gi = path.join(process.cwd(), ".gitignore");
+        if (!fs.existsSync(gi)) {
+            fs.writeFileSync(gi, DEFAULT_GITIGNORE);
+            print(C.faint("  added a .gitignore (node_modules, .env, build output) so secrets and junk aren't committed"));
+        }
+        git(["init", "-q"]);
+        git(["add", "-A"]);
+        const c = git(["commit", "-q", "--allow-empty", "-m", "huddle: starting point"]);
+        if (!c.ok) {
+            print(C.red("  ✗ couldn't make the first commit.") + C.faint(" Is git's user.name / user.email set?"));
+            return false;
+        }
+        print(`  ${C.green("✓")} git repo ready`);
+    }
+    ensureInit();
+    const dirty = git(["status", "--porcelain"]).out.split("\n").filter((l) => l && !l.includes(".huddle/"));
+    if (dirty.length) {
+        if (!rl) {
+            print(C.yellow(`! ${dirty.length} uncommitted change(s) — agents only see committed files.`));
+            return true;
+        }
+        print(C.yellow(`\n  You have ${dirty.length} uncommitted change(s).`) + C.faint(" Agents only see committed files."));
+        if (await yes(rl, "  Commit them as a checkpoint first?")) {
+            git(["add", "-A"]);
+            git(["commit", "-q", "-m", `huddle: checkpoint before "${goal.slice(0, 60)}"`]);
+            print(`  ${C.green("✓")} checkpoint committed`);
+        }
+    }
+    return true;
+}
+/** Remove worktrees left behind by a crashed or stopped run. */
+function sweepWorktrees(root) {
+    const mine = path.join(root, ".huddle", "worktrees");
+    for (const wt of listWorktrees(root))
+        if (wt.startsWith(mine))
+            removeWorktree(root, wt);
+}
+/** A goal for a header line: long goals (a whole spec) don't fill the screen. */
+function shortGoal(goal, n = 100) {
+    const one = goal.replace(/\s+/g, " ").trim();
+    return one.length > n ? one.slice(0, n - 1).replace(/\s+\S*$/, "") + "…" : one;
+}
+/**
+ * The plan's "→ likely <agent>" guess per task. It replays the scheduler's
+ * hand-out in waves: each wave, the free agents in fairness order (fewest
+ * tasks so far, roster order breaks ties) each take the ready task that best
+ * matches their tags, earliest first on a tie, exactly as fill() and
+ * nextBacklogTask do; a task is ready once every task it depends on was handed
+ * out in an earlier wave. Found live (capstone round 2): the old per-task guess
+ * said "likely codex" for task 1, which claude took, because the scheduler
+ * lets each agent pick, not each task. (Before that, a prefers-first sort said
+ * "likely codex" on all 5 tasks.)
+ */
+export function likelyAgents(tasks, workers) {
+    const out = tasks.map(() => undefined);
+    if (!workers.length)
+        return out;
+    const given = new Map();
+    const wave = new Map(); // task index -> the wave it was handed out in
+    for (let n = 0; wave.size < tasks.length; n++) {
+        const order = workers.map((w, i) => ({ w, i })).sort((a, b) => (given.get(a.w.id) ?? 0) - (given.get(b.w.id) ?? 0) || a.i - b.i);
+        let any = false;
+        for (const { w } of order) {
+            const ready = tasks
+                .map((t, i) => ({ t, i }))
+                .filter(({ t, i }) => !wave.has(i) && (t.depends_on ?? []).every((d) => (wave.get(d) ?? n) < n));
+            if (!ready.length)
+                break;
+            const score = (t) => t.prefers.filter((p) => prefersOf(w).includes(p)).length;
+            const pick = ready.sort((a, b) => score(b.t) - score(a.t) || a.i - b.i)[0];
+            wave.set(pick.i, n);
+            out[pick.i] = w.id;
+            given.set(w.id, (given.get(w.id) ?? 0) + 1);
+            any = true;
+        }
+        if (!any)
+            break; // a dependency that can never be met (a cycle): leave the rest unguessed
+    }
+    return out;
+}
+function printPlan(print, goal, plan, workers) {
+    const took = plan.ms ? ` in ${fmtDuration(plan.ms)}` : "";
+    print(`\n${C.violet("PLAN")} ${C.faint("· " + shortGoal(goal) + " · by " + plan.by + took + (plan.note ? " — " + plan.note : ""))}`);
+    const startable = plan.tasks.filter((t) => !t.depends_on?.length).length;
+    const likely = likelyAgents(plan.tasks, workers);
+    plan.tasks.forEach((t, i) => {
+        const after = t.depends_on?.length ? C.faint(`  after ${t.depends_on.map((d) => d + 1).join(", ")}`) : "";
+        const fit = likely[i];
+        const idea = t.from?.length ? C.faint(`  · idea: ${t.from.join(", ")}`) : "";
+        print(`  ${C.faint(String(i + 1) + ".")} ${t.title}${after}  ${fit ? C.faint("→ likely ") + dot(fit) + " " + fit : ""}${idea}`);
+    });
+    print(C.faint(`  ${plan.tasks.length} task(s), ${Math.min(startable, workers.length)} of ${workers.length} agents can start right away`));
+    // The council's agreements, which every agent can huddle_recall mid-task.
+    for (const d of plan.council?.decisions ?? [])
+        print(`  ${C.violet("◆")} ${C.faint("decided:")} ${oneLine(d, 110)}`);
+    for (const r of plan.council?.risks ?? [])
+        print(`  ${C.yellow("!")} ${C.faint("risk" + (r.by ? ` (${r.by})` : "") + ":")} ${oneLine(r.body, 105)}`);
+}
+/** Show a spinner line while a promise settles (TTY only). */
+async function withSpinner(label, p) {
+    if (!process.stdout.isTTY)
+        return p;
+    const t0 = Date.now();
+    const live = new LiveLines((spin) => [`  ${spin} ${C.faint(label)} ${C.faint(fmtDuration(Date.now() - t0))}`]).start();
+    try {
+        return await p;
+    }
+    finally {
+        live.stop();
+        process.stdout.write("\x1b[1A\x1b[2K"); // remove the spinner line
+    }
+}
+export async function runGoal(goal, opts) {
+    const print = opts.print ?? ((l = "") => console.log(l));
+    // Typed at the prompt too: `build a todo app from scratch --no-council`.
+    const flagIn = goal.match(/(^|\s)--(no-)?council(?=\s|$)/);
+    if (flagIn)
+        goal = goal.replace(flagIn[0], " ").replace(/\s+/g, " ").trim();
+    const councilFlag = opts.council ?? (flagIn ? !flagIn[2] : undefined);
+    const workers = workersFrom(opts.results);
+    // One-shot `huddle join` (no rl): a failure exits 1, and the hints name CLI commands.
+    if (!workers.length && !opts.room?.server.remote.workers().length) {
+        print(C.red("\n✗ No agents ready.") +
+            (opts.rl ? " Type `agents` to install or sign in." : " Run `huddle doctor` to see what's missing, or `huddle` to set agents up (it asks first)."));
+        if (!opts.rl)
+            process.exitCode = 1;
+        return;
+    }
+    if (!(await prepareRepo(print, opts.rl, goal))) {
+        if (!opts.rl)
+            process.exitCode = 1;
+        return;
+    }
+    const root = repoRoot();
+    const rl = opts.rl;
+    // Teammates' agents (from `huddle join` on their machines) work alongside yours.
+    const bridge = opts.room?.server.remote;
+    const remoteNow = () => (bridge?.workers() ?? []).map((r) => ({ id: r.id, remote: r }));
+    const brain = resolveBrain(opts.results, opts.probed);
+    const crew = [...workers, ...remoteNow()].map((w) => ({ id: w.id, prefers: prefersOf(w) })); // one entry per agent, teammates' included
+    const members = councilMembers(workers);
+    // Files in the repo before the run: an (almost) empty repo makes a goal a project (goalSize in planner.ts).
+    const repoFiles = git(["ls-files"], root).out.split("\n").filter(Boolean).length;
+    const wantCouncil = councilWanted(goal, { flag: councilFlag, members: members.length, repoFiles });
+    if (councilFlag === true && !wantCouncil.yes)
+        print(C.yellow(`  ! no design council: ${wantCouncil.why}`));
+    let plan;
+    if (wantCouncil.yes) {
+        print(`\n${C.violet("COUNCIL")} ${C.faint(`· ${members.map((m) => m.id).join(", ")} brainstorm before anyone codes · ${wantCouncil.why} (--no-council skips)`)}`);
+        const say = (agent, text) => {
+            print(`  ${dot(agent)} ${pad(agent, 12)} ${text}`);
+            opts.onActivity?.({ agent, text });
+        };
+        const onCouncil = (e) => {
+            if (e.type === "round")
+                print(C.faint(`  ${e.round === "proposal" ? "1/3 each agent proposes a design…" : "2/3 each agent critiques the others…"}`));
+            if (e.type === "synthesizing")
+                print(C.faint(`  3/3 ${e.brain} merges the best ideas into one plan…`));
+            if (e.type !== "entry")
+                return;
+            const x = e.entry;
+            const took = C.faint(` · ${fmtDuration(x.ms)}`);
+            if (!x.ok)
+                return say(x.agent, C.faint(`${x.round} skipped (${x.skipped})`) + took);
+            if (x.round === "proposal")
+                return say(x.agent, `${C.faint("proposes:")} ${oneLine(headline(x.text, "ARCHITECTURE"), 100)}` + took);
+            const flaw = headline(x.text, "FLAWS");
+            const next = headline(x.text, "NEXT");
+            say(x.agent, `${C.faint("flags:")} ${oneLine(flaw, 100)}` + took);
+            if (next && next !== flaw)
+                print(`  ${" ".repeat(15)}${C.faint("next:")} ${oneLine(next, 100)}`);
+        };
+        plan = await runCouncil(goal, crew, members, root, { brain, signal: opts.signal, onEvent: onCouncil });
+    }
+    else {
+        // A big goal without a council (--no-council, or one agent) still gets a project-sized plan.
+        const project = !listsOwnTasks(goal) && isBigGoal(goal, { repoFiles });
+        plan = await withSpinner(`planning with ${brain?.label ?? "template"}…`, planGoal(goal, crew, root, { brain, signal: opts.signal, project }));
+    }
+    if (opts.signal?.aborted)
+        return;
+    printPlan(print, goal, plan, workers);
+    if (opts.mode === "plan") {
+        print(C.faint("\n  plan mode — nothing created or spawned. " +
+            (rl ? "shift+tab to switch mode and run it." : `Run it: huddle join ${JSON.stringify(goal)}`)));
+        return;
+    }
+    if (opts.mode === "manual" && rl && !(await yes(rl, `\nStart with ${workers.map((w) => w.id).join(", ")}?`)))
+        return;
+    sweepWorktrees(root);
+    // Code layer: start from the latest shared main, and (once, per repo) ask
+    // whether merged work should be pushed back.
+    const remote = remoteInfo(root);
+    let sync = readRepoConfig(root).sync;
+    if (remote && sync === undefined && rl) {
+        print(C.faint(`\n  This repo shares code through ${remote.name} (${remote.url}).`));
+        sync = await yes(rl, `  Push merged work to ${remote.name}/${remote.branch} automatically after each run?`);
+        writeRepoConfig(root, { sync });
+        print(C.faint(sync ? "  ✓ auto-push on — change with `sync off`" : "  ok — merges stay local; `sync on` to change"));
+    }
+    if (remote && sync) {
+        const p = pullLatest(root);
+        print(C.faint(`  ${p.ok ? "↓" : "!"} ${remote.name}: ${p.note}`));
+    }
+    const startHead = git(["rev-parse", "HEAD"], root).out;
+    const testCmd = detectTestCmd(root);
+    const ownRoom = !opts.room;
+    const db = opts.room?.db ?? new RoomDB(dbPath());
+    db.clearBoard();
+    const room = opts.room?.server ?? (await startRoom(db, ROOM_PORT));
+    const taskIds = seedBoard(db, goal, plan.tasks);
+    // Who planned it, for `huddle story` (the tasks themselves are task.added events).
+    db.publish("plan.made", { payload: { by: plan.by, note: plan.note ?? null, ms: plan.ms ?? null, tokens: plan.tokens ?? null, tasks: plan.tasks.length } });
+    // Before the live listener below, so the council's memories aren't printed twice.
+    if (plan.council)
+        recordCouncil(db, plan.council, plan.tasks, taskIds);
+    print(`\n${C.violet("●")} room live ${C.faint("· " + room.url)}  ${C.faint("· tests: " + (testCmd ?? "none yet"))}` +
+        `  ${C.faint("· approvals: " + opts.approvals)}` +
+        (rl ? C.faint("  · ctrl-t live view · keep typing — board, questions · ctrl-c stops") : "") +
+        "\n");
+    const tag = (agent) => `${dot(agent)} ${pad(agent, 12)}`;
+    const act = (agent, text) => opts.onActivity?.({ agent, text });
+    const unsub = db.onEvent((e) => {
+        const p = JSON.parse(e.payload || "{}");
+        if (e.type === "task.progress" && p.note) {
+            const agent = (e.task_id ? db.getTask(e.task_id)?.claimed_by : "") ?? "";
+            print(`  ${tag(agent)} ${C.faint(String(p.pct).padStart(3) + "%")}  ${oneLine(p.note, 100)}`);
+            act(agent, `${C.faint(String(p.pct).padStart(3) + "%")} ${p.note}`);
+        }
+        else if (e.type === "memory.added" && p.author !== "huddle") {
+            print(`  ${C.violet("◆")} ${pad(C.faint("memory"), 12)}  ${oneLine(p.body, 100)}`);
+            act(undefined, `${C.violet("◆")} ${C.faint(p.author + " remembered:")} ${oneLine(p.body, 200)}`);
+        }
+        else if (e.type === "plan.announced" && e.agent_id) {
+            print(`  ${tag(e.agent_id)} ${C.faint("plans:")} ${oneLine(p.intent ?? "", 100)}`);
+            act(e.agent_id, `${C.faint("plans:")} ${p.intent ?? ""}`);
+        }
+        else if (e.type === "agent.message" && p.kind !== "question") {
+            // Agent to agent, live: "codex → claude: renamed greet() to hello()". (Questions show as asks.)
+            const arrow = `${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${dot(p.to)} ${C.bold(p.to)}`;
+            print(`  ${arrow}${C.faint(":")} ${oneLine(p.body, 110)}${p.kind === "answer" ? C.faint("  (answer)") : ""}`);
+            act(undefined, `${arrow}${C.faint(":")} ${oneLine(p.body, 200)}`);
+        }
+    });
+    const t0 = Date.now();
+    const stats = newStats([...workers, ...remoteNow()].map((w) => w.id));
+    opts.onStats?.(stats);
+    const tok = (tokens, cached) => `${fmtTokens(tokens)} tok` + (cached > tokens / 2 ? ` (${fmtTokens(cached)} cached)` : "");
+    const cost = (ms, tokens, cached) => C.faint(` · ${fmtDuration(ms)} · ${tok(tokens, cached)}`);
+    if (remoteNow().length && !(remote && sync))
+        print(C.yellow("  ! teammates' agents need the code on a shared remote — `sync on` (and a GitHub remote) to hand them tasks"));
+    const boardOpts = {
+        db,
+        repoRoot: root,
+        bridge,
+        remoteWorkers: remoteNow,
+        // Teammates branch off what's pushed, so push main before each hand-off.
+        publish: () => {
+            if (!remote || !sync)
+                return null;
+            const p = pushMerged(root);
+            return p.ok ? git(["rev-parse", "HEAD"], root).out : null;
+        },
+        roomUrl: room.url,
+        roomSecret: room.secret,
+        workers,
+        testCmd: (worktree) => detectTestCmd(worktree),
+        approvals: opts.approvals,
+        signal: opts.signal,
+        approveMerge: opts.mode === "manual" && rl
+            ? async ({ agent, title, diffstat }) => {
+                print(`\n  ${tag(agent)} ${C.violet("◎ ready")}  ${title}`);
+                for (const l of (diffstat || "(no changes)").split("\n"))
+                    print(C.faint("      " + l.trim()));
+                return yes(rl, "  Merge it?");
+            }
+            : undefined,
+        onEvent: (e) => {
+            // HUDDLE_EVENTS_FILE=<path>: every scheduler event as a JSON line (evals, post-mortems).
+            if (process.env.HUDDLE_EVENTS_FILE)
+                fs.appendFileSync(process.env.HUDDLE_EVENTS_FILE, JSON.stringify({ ts: Date.now(), ...e }) + "\n");
+            if ("agent" in e && !stats.agents.has(e.agent))
+                stats.agents.set(e.agent, { busySince: null, liveTokens: 0, tokens: 0, cached: 0, ms: 0, tasks: 0, reviews: 0 });
+            const a = "agent" in e ? stats.agents.get(e.agent) : undefined;
+            if (e.type === "start" && a)
+                Object.assign(a, { busySince: Date.now(), liveTokens: 0 });
+            if (e.type === "tokens" && a)
+                a.liveTokens = e.tokens;
+            if (e.type === "start" && a)
+                a.liveTokens = -1; // -1 = not reported yet
+            if ((e.type === "merged" || e.type === "failed") && a)
+                Object.assign(a, {
+                    busySince: null,
+                    liveTokens: 0,
+                    tokens: a.tokens + e.tokens,
+                    cached: a.cached + e.cached,
+                    ms: a.ms + e.ms,
+                    tasks: a.tasks + 1,
+                });
+            if (e.type === "review" && a)
+                Object.assign(a, { busySince: Date.now(), liveTokens: -1 });
+            if (e.type === "reviewed" && a)
+                Object.assign(a, { busySince: null, ms: a.ms + e.ms, reviews: a.reviews + 1 });
+            if (e.type === "takeover") {
+                // The author's rounds end here (no merged/failed event for it): count them.
+                const f = e.kind === "rescue" ? stats.agents.get(e.from) : undefined;
+                if (f)
+                    Object.assign(f, { busySince: null, liveTokens: 0, tokens: f.tokens + e.tokens, cached: f.cached + e.cached, ms: f.ms + e.ms });
+                const what = e.kind === "rescue" ? `took over ${e.from}'s` : `took part of ${e.from}'s task:`;
+                act(e.agent, `${C.yellow("⤳")} ${what} ${e.title} ${C.faint("· " + e.reason)}`);
+                print(`  ${tag(e.agent)} ${C.yellow("⤳ " + what)} “${e.title}” ${C.faint("· " + oneLine(e.reason, 110))}`);
+            }
+            if (e.type === "start")
+                act(e.agent, `${C.violet("▸")} ${e.takeover ? `continuing ${e.takeover}'s work: ` : e.fixing ? "fixing after review: " : ""}${e.title}`);
+            if (e.type === "merged")
+                act(e.agent, `${C.green("✓ merged")} ${e.title}`);
+            if (e.type === "failed")
+                act(e.agent, `${C.red("✗ failed")} ${e.title} ${C.faint("· " + e.reason)}`);
+            if (e.type === "review")
+                act(e.agent, `${C.violet("◎")} reviewing ${e.author}'s work`);
+            if (e.type === "reviewed")
+                act(e.agent, e.approve ? C.green("✓ approved " + e.author) : C.yellow("✎ asked " + e.author + " for changes"));
+            if (e.type === "start")
+                print(`  ${tag(e.agent)} ${C.violet("▸")} ${e.takeover ? C.yellow(`continuing ${e.takeover}'s work: `) : e.fixing ? C.yellow("fixing after review: ") : ""}${e.title}` +
+                    (e.remote ? C.faint(`  · offered to ${e.remote}`) : ""));
+            if (e.type === "handoff")
+                print(`  ${tag(e.agent)} ${C.violet("⇢")} handoff from ${C.bold(e.from)} ${C.faint(`· ${e.files} file(s), ${e.symbols} export(s) · “${e.title}”`)}`);
+            if (e.type === "declined")
+                print(`  ${tag(e.agent)} ${C.faint("✗ declined · back on the board")}  ${C.faint(e.title)}`);
+            if (e.type === "review")
+                print(`  ${tag(e.agent)} ${C.violet("◎")} reviewing ${e.author}'s ${C.faint("“" + e.title + "”")}`);
+            if (e.type === "reviewed") {
+                if (e.skipped)
+                    print(`  ${tag(e.agent)} ${C.faint("○ review skipped")} ${C.faint("· " + e.notes + " · " + fmtDuration(e.ms) + " · merging on tests alone")}`);
+                else if (e.approve)
+                    print(`  ${tag(e.agent)} ${C.green("✓ approved")} ${e.author}'s work ${C.faint("· " + fmtDuration(e.ms))}`);
+                else {
+                    print(`  ${tag(e.agent)} ${C.yellow("✎ asked for changes")} ${C.faint("· " + fmtDuration(e.ms) + " · back to " + e.author)}`);
+                    for (const l of e.notes.split("\n").slice(0, 4))
+                        print(C.faint(`      ${oneLine(l, 110)}`));
+                }
+            }
+            if (e.type === "merged")
+                print(`  ${tag(e.agent)} ${C.green("✓ merged")}  ${e.title} ${C.faint("· " + e.reason)}${cost(e.ms, e.tokens, e.cached)}`);
+            if (e.type === "failed")
+                print(`  ${tag(e.agent)} ${e.needsYou ? C.yellow("! needs you") : C.red("✗ failed")}  ${e.title} ${C.faint("· " + e.reason)}${cost(e.ms, e.tokens, e.cached)} ${C.faint("· log: " + tildify(e.log))}`);
+            if (e.type === "conflict" && a)
+                Object.assign(a, { busySince: Date.now(), liveTokens: -1 });
+            if (e.type === "resolved" && a)
+                Object.assign(a, { busySince: null, ms: a.ms + e.ms });
+            if (e.type === "conflict") {
+                act(e.agent, `${C.yellow("⇄")} resolving a conflict in ${e.author}'s work`);
+                print(`  ${tag(e.agent)} ${C.yellow("⇄ resolving conflict")} ${C.faint("in " + e.files.join(", "))}  ${e.title}` +
+                    C.faint(` · ${e.agent === e.author ? "its own work" : e.author + "'s work"} vs main · try ${e.attempt}`));
+            }
+            if (e.type === "resolved")
+                print(`  ${tag(e.agent)} ${e.ok ? C.green("✓ resolved") : C.yellow("✗ resolution rejected")} ${C.faint("· " + e.reason + " · " + fmtDuration(e.ms))}`);
+            if (e.type === "stuck")
+                print(C.yellow(`  ! ${e.blocked.length} task(s) blocked by failures: `) + C.faint(e.blocked.join(" · ")));
+        },
+    };
+    const res = await runBoard(boardOpts);
+    // QA: agents that didn't write the code re-check the integrated main; bugs
+    // they file become routed fix tasks, run through this same board.
+    let qaNote = "";
+    if (!res.stopped && res.merged && shouldQa(goal, { flag: opts.qa, tasks: plan.tasks.length, repoFiles })) {
+        if (res.failed)
+            print(C.faint(`\n  QA skipped — ${res.failed} task(s) didn't merge; it checks finished builds only`));
+        else {
+            print(`\n${C.violet("QA")} ${C.faint("· agents that didn't write it check the build · --no-qa to skip")}`);
+            const qa = await runQa({
+                db,
+                room,
+                repoRoot: root,
+                goal,
+                startHead,
+                workers,
+                approvals: opts.approvals,
+                testCmd: (wt) => detectTestCmd(wt),
+                signal: opts.signal,
+                runFixes: () => runBoard(boardOpts),
+                onEvent: (e) => {
+                    if (process.env.HUDDLE_EVENTS_FILE)
+                        fs.appendFileSync(process.env.HUDDLE_EVENTS_FILE, JSON.stringify({ ts: Date.now(), qa: true, ...e }) + "\n");
+                    qaLine(e, tag, print, act, stats);
+                },
+            });
+            res.merged += qa.fixed;
+            res.failed += qa.failed;
+            res.stopped ||= qa.stopped;
+            qaNote = qa.clean
+                ? `QA: ${qa.rounds} round(s) by agents re-checking the integrated build; ${qa.bugs} bug(s) filed, ${qa.fixed} fix(es) merged, the last round came back clean.`
+                : `QA: ${qa.rounds} round(s); ${qa.bugs} bug(s) filed, ${qa.fixed} fix(es) merged, but the last round did NOT come back clean.`;
+        }
+    }
+    unsub();
+    const doneNotes = db.recall().filter((m) => /^Task \S+ done:/.test(m.body)).map((m) => `- (${m.author}) ${m.body}`);
+    const parked = db.listTasks().filter((t) => t.status === "needs_you");
+    const takeovers = new Map(); // task id -> the branch a rescuer continued on
+    for (const ev of db.eventsOfType(["task.takeover"], t0 - 1, 500)) {
+        const p = JSON.parse(ev.payload || "{}");
+        if (ev.task_id && p.kind === "rescue" && p.branch)
+            takeovers.set(ev.task_id, String(p.branch));
+    }
+    if (ownRoom) {
+        room.close();
+        db.close();
+    }
+    opts.onStats?.(stats);
+    const head = res.stopped ? C.yellow("■ stopped") : res.failed ? C.yellow("◎") : C.green("✓");
+    const total = [...stats.agents.values()].reduce((n, a) => n + a.tokens, 0);
+    const totalCached = [...stats.agents.values()].reduce((n, a) => n + a.cached, 0);
+    print(`\n${head} ${res.merged} merged, ${res.failed} failed ${C.faint(`· ${fmtDuration(Date.now() - t0)} · ${tok(total, totalCached)}`)}`);
+    for (const [id, a] of stats.agents) {
+        if (!a.tasks && !a.reviews && !a.qa) {
+            print(`  ${tag(id)} ${C.faint("idle this run")}`);
+            continue;
+        }
+        const did = [
+            a.tasks ? `${a.tasks} task${a.tasks > 1 ? "s" : ""}` : "",
+            a.reviews ? `${a.reviews} review${a.reviews > 1 ? "s" : ""}` : "",
+            a.qa ? `${a.qa} QA` : "",
+        ]
+            .filter(Boolean)
+            .join(" + ");
+        print(`  ${tag(id)} ${pad(did, 18)} ${pad(fmtDuration(a.ms), 7)} ${a.tasks ? tok(a.tokens, a.cached) : ""}`);
+    }
+    for (const t of parked) {
+        // Never resolved by force: the branch holds the agent's work exactly as it left it.
+        // A taken-over task still lives on its first agent's branch.
+        const tk = takeovers.get(t.id);
+        const wt = tk ? { branch: tk } : worktreeFor(root, t.claimed_by ?? "", t.id);
+        print(C.yellow(`  ! needs you: ${t.title}`) + C.faint(` — ${tk ? "two agents couldn't land it" : "conflicts with main"}; work kept on ${wt.branch}`));
+        print(C.faint(`      to take it yourself: git merge ${wt.branch}   # resolve the markers, then commit`));
+    }
+    if (res.merged && remote && sync) {
+        const p = pushMerged(root);
+        print(p.ok ? `  ${C.green("↑")} git push · all in one go ${C.faint("→ " + p.note)}` : C.yellow(`  ! not pushed: ${p.note}`));
+    }
+    if (res.merged)
+        await deliver(print, goal, root, startHead, doneNotes, brain, reportFacts(root, startHead, { ...res, testCmd: detectTestCmd(root), qaNote }));
+}
+/** QA's readable lines: "cursor (QA) found: …", "→ fix assigned to codex". */
+function qaLine(e, tag, print, act, stats) {
+    const a = "agent" in e ? stats.agents.get(e.agent) : undefined;
+    if (e.type === "round")
+        print(`  ${C.violet("◎")} ${C.bold(`QA round ${e.round}`)} ${C.faint("· checked by " + e.agents.join(", "))}`);
+    if (e.type === "start") {
+        if (a)
+            Object.assign(a, { busySince: Date.now(), liveTokens: -1 });
+        print(`  ${tag(e.agent)} ${C.violet("◎")} QA: tests, using it, reading the diff${e.author ? C.faint(" · (everyone wrote some — checking anyway)") : ""}`);
+        act(e.agent, `${C.violet("◎")} QA round ${e.round}`);
+    }
+    if (e.type === "bug") {
+        print(`  ${tag(e.agent)} ${C.yellow("✗ (QA) found:")} ${oneLine(e.title, 90)}${e.files.length ? C.faint(" · " + e.files.join(", ")) : ""}${e.test ? C.faint(" · + regression test") : ""}`);
+        print(`  ${pad("", 14)} ${C.faint("→ fix assigned to")} ${e.assignedTo ? `${dot(e.assignedTo)} ${e.assignedTo}` : C.faint("any free agent")}`);
+        act(e.agent, `${C.yellow("✗ found:")} ${e.title} ${C.faint("→ " + (e.assignedTo ?? "anyone"))}`);
+    }
+    if (e.type === "duplicate")
+        print(`  ${tag(e.agent)} ${C.faint(`= duplicate of “${oneLine(e.of, 70)}” · not filed again`)}`);
+    if (e.type === "checked") {
+        if (a)
+            Object.assign(a, { busySince: null, ms: a.ms + e.ms, tokens: a.tokens + e.tokens, qa: (a.qa ?? 0) + 1 });
+        print(`  ${tag(e.agent)} ${e.ok ? C.green("✓ QA done") : C.yellow("! QA didn't finish")} ${C.faint(`· ${e.bugs} bug(s) filed · ${fmtDuration(e.ms)}${e.reason ? " · " + e.reason : ""}`)}`);
+    }
+    if (e.type === "fixes")
+        print(`  ${C.violet("◎")} ${C.faint(`QA round ${e.round} fixes: ${e.merged} merged, ${e.failed} failed`)}`);
+    if (e.type === "clean")
+        print(`  ${C.green("✓")} QA round ${e.round} clean ${C.faint("· nothing found")}`);
+    if (e.type === "unchecked")
+        print(C.yellow(`  ! QA round ${e.round}: the build was NOT checked`) + C.faint(` · ${e.reason}`));
+    if (e.type === "capped")
+        print(C.yellow(`  ! QA stopped after ${e.round} round(s)`) + C.faint(` · the last round's fixes weren't re-checked${e.open ? ` · ${e.open} still open` : ""}`));
+    if (e.type === "skipped")
+        print(C.faint(`  QA skipped — ${e.reason}`));
+}
+/**
+ * What Huddle itself verified during the run, for the report: the brain only
+ * sees notes and a diffstat, so without these it hedges. Found live (capstone
+ * round 3): "I don't know whether the final state is committed" and "the agents
+ * reported 82/82, I did not re-run them" — after Huddle had merged all 10 tasks
+ * as commits, each through its test gate, and QA had come back clean. The same
+ * report blamed "plan mode" — the brain's own read-only flag — so the brief says
+ * that's Huddle's choice, not the run's.
+ */
+export function reportFacts(root, startHead, o) {
+    const subjects = git(["log", "--format=%s", `${startHead}..HEAD`], root).out.split("\n").filter(Boolean);
+    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root).out.trim() || "the current branch";
+    const facts = [
+        `${o.merged} task(s) merged and ${o.failed} failed. The merged work is already committed: ${subjects.length} commit(s) on ${branch} since the run started (git log ${startHead.slice(0, 7)}..HEAD).`,
+        o.testCmd
+            ? `Huddle ran \`${o.testCmd}\` before every merge, after rebasing onto the latest ${branch}; nothing merged with failing tests.`
+            : "No test command was detected, so merges were not gated on tests.",
+    ];
+    if (o.qaNote)
+        facts.push(o.qaNote);
+    if (o.stopped)
+        facts.push("The run was stopped before every task finished.");
+    return facts;
+}
+/** The brain's prompt for the "what you got" report. */
+export function reportPrompt(o) {
+    const facts = o.facts?.length
+        ? `\nVERIFIED BY HUDDLE (facts — state them plainly; never say you don't know whether the work is committed or tested):\n${o.facts.map((f) => "- " + f).join("\n")}\n`
+        : "";
+    return `Several AI agents just finished this goal in the repo in your current directory: "${o.goal}".
+Their notes:\n${o.notes.join("\n")}\n\nFiles changed:\n${o.stat}\n${facts}
+Write the final report for the user, like the last message of a coding session. Plain text, no markdown headings, under 15 lines:
+1) one or two sentences on what now exists, 2) exactly how to run or try it (real commands for this repo),
+3) anything unfinished or worth checking. ${o.readsRepo ? "Read the repo if you need to confirm commands. " : ""}Do not edit anything.
+You run read-only because Huddle only asks you for this write-up; the run itself was not in plan mode, so don't mention plan mode or your own read-only limits.`;
+}
+/**
+ * The "what you got" report — like the last message from Claude Code: what was
+ * built, how to run it, what's left. Written read-only by one agent from the
+ * merged diff and the agents' done notes; falls back to the raw notes.
+ */
+async function deliver(print, goal, root, startHead, notes, brain, facts = []) {
+    const stat = git(["diff", "--stat", `${startHead}..HEAD`], root).out;
+    let summary = "";
+    if (brain) {
+        const prompt = reportPrompt({ goal, notes, stat, facts, readsRepo: brain.readsRepo });
+        const r = await withSpinner(`${brain.label} is writing up what you got…`, brain.think(prompt, root, { timeoutMs: 3 * 60_000 }));
+        if (r.ok)
+            summary = r.text;
+    }
+    print(`\n${C.violet("WHAT YOU GOT")} ${C.faint("· " + shortGoal(goal))}`);
+    if (summary)
+        for (const l of summary.split("\n"))
+            print("  " + l);
+    else
+        for (const n of notes)
+            print("  " + oneLine(n, 160));
+    if (stat)
+        print(C.faint("\n  " + stat.split("\n").pop().trim() + C.faint("  ·  see it all: git log")));
+}
+/** Answer a question about the repo, read-only. */
+async function answer(print, question, results, signal) {
+    // Questions need to look around the repo, so a local brain (which can't read
+    // files) hands them to the best agent instead.
+    let brain = resolveBrain(results);
+    if (brain && !brain.readsRepo) {
+        const asker = pickAsker(workersFrom(results).map((w) => w.adapter));
+        brain = asker ? brainFrom(asker.id === "claude" ? "claude:sonnet" : asker.id) : null;
+    }
+    if (!brain) {
+        print(C.red("  ✗ no agent ready to answer.") + " Type `agents`.");
+        return;
+    }
+    const prompt = `${question}\n\n(Answer about the project in your current directory. You are read-only: look around, don't edit. Be concise and concrete — plain text, short lines, no markdown headings.)`;
+    const r = await withSpinner(`${brain.label} is looking…`, brain.think(prompt, process.cwd(), { signal }));
+    const who = brain.spec.split(":")[0];
+    print(`\n${dot(who)} ${C.bold(brain.label)} ${C.faint("· " + fmtDuration(r.ms))}`);
+    for (const l of (r.text || "(no answer)").split("\n"))
+        print("  " + l);
+}
+// ---- board -------------------------------------------------------------------
+export function printBoard(print = (l = "") => console.log(l)) {
+    if (!fs.existsSync(dbPath())) {
+        print(C.faint("  no board yet — type a goal to start."));
+        return;
+    }
+    const db = new RoomDB(dbPath());
+    const s = db.currentSession();
+    print(`\n${C.violet("BOARD")} ${C.faint("· " + (s?.goal ?? "(no goal yet)"))}`);
+    for (const t of db.listTasks()) {
+        const w = 16;
+        const filled = Math.round((t.progress_pct / 100) * w);
+        const bar = C.violet("█".repeat(filled)) + C.faint("░".repeat(w - filled));
+        const who = t.claimed_by ? `${dot(t.claimed_by)} ${t.claimed_by}` : C.faint("unclaimed");
+        print(`  ${statusLabel(t.status)} ${bar} ${String(t.progress_pct).padStart(3)}%  ${t.title}  ${who}`);
+    }
+    const mem = db.recall();
+    if (mem.length) {
+        print(`\n${C.violet("SHARED MEMORY")}`);
+        for (const m of mem.slice(0, 8))
+            print(`  ${C.faint("•")} ${m.body}${m.why ? C.faint(" — why: " + m.why) : ""} ${C.faint("(" + m.author + ")")}`);
+    }
+    print();
+    db.close();
+}
+function statusLabel(s) {
+    const map = {
+        merged: C.green("✓ merged "),
+        failed: C.red("✗ failed "),
+        in_progress: C.yellow("▸ working"),
+        review: C.yellow("◎ review "),
+        claimed: C.faint("◐ claimed"),
+    };
+    return map[s] ?? C.faint("○ backlog");
+}
+// ---- the REPL ------------------------------------------------------------------
+const MODES = ["manual", "auto", "plan"];
+const MODE_INFO = {
+    manual: { chip: C.faint("◇ manual"), desc: "you approve the plan and every merge" },
+    auto: { chip: C.violet("⏵⏵ auto"), desc: "runs and merges on green, no questions" },
+    plan: { chip: C.hex("#4AA3A2")("⏸ plan"), desc: "shows the plan only, runs nothing" },
+};
+const APPROVALS = {
+    safe: "file edits only — commands are refused",
+    auto: "skip most approvals — commands run sandboxed",
+    yolo: "approve everything — no sandbox",
+};
+const HELP = `
+  ${C.bold("<goal>")}              just type what you want built
+  ${C.bold("<question>?")}         ask about the project — answered read-only, nothing changes
+  ${C.bold("build <goal>")}        force a build  ${C.faint("·")}  ${C.bold("ask <question>")}  force a question
+  ${C.bold("<goal> --qa")} ${C.faint("/")} ${C.bold("--no-qa")}   agents re-check the build and fix what they find ${C.faint("(default: big goals)")}
+  ${C.bold("shift+tab")}           switch mode: ${MODES.map((m) => MODE_INFO[m].chip).join(C.faint(" → "))}
+  ${C.bold("approvals")} ${C.faint("[level]")}   what agents may do without asking: safe · auto · yolo
+  ${C.bold("brain")} ${C.faint("[model]")}       what Huddle plans & reviews with — e.g. a free local model
+  ${C.bold("crew")} ${C.faint("[agent=n …]")}    how many of each agent: crew claude=2 codex=1 cursor=0
+  ${C.bold("invite")} ${C.faint("@user [guest]")} let a GitHub user into this room — one-time code, 10 min
+  ${C.bold("members")}             who's in the room  ${C.faint("·")}  ${C.bold("remove <name>")}  take someone out, instantly
+  ${C.bold("sync")} ${C.faint("[on|off]")}       push merged work to GitHub after each run (asked once per repo)
+  ${C.bold("relay")} ${C.faint("[url|off]")}      a relay so invites work across any networks
+  ${C.bold("funnel")} ${C.faint("[on|off]")}      public https invites through Tailscale Funnel
+  ${C.bold("ctrl-t")} ${C.faint("or")} ${C.bold("view")}      the live view — 1 agents · 2 plan · 3 board · q to come back
+  ${C.bold("board")}               the task board and shared memory
+  ${C.bold("agents")}              reconnect agents; install or sign in to missing ones
+  ${C.bold("cd <dir>")}            move to another project  ${C.faint("·")}  ${C.bold("!<cmd>")}  run a shell command
+  ${C.bold("ctrl-c")}              stop a run  ${C.faint("(or clear the line)")}
+  ${C.bold("exit")}                leave  ${C.faint("(or ctrl-d)")}
+
+  ${C.faint("While agents work you can keep typing: board, approvals and questions work live; a new goal is queued.")}
+`;
+// Things people type out of habit that are shell commands, not goals.
+const SHELL_WORDS = new Set(["mkdir", "rm", "mv", "cp", "touch", "echo", "git", "ls", "pwd", "cat", "npm", "npx", "node", "pnpm", "yarn", "python", "python3", "code", "tree", "head", "tail"]);
+const QUESTION = /^(what|what's|where|why|how|who|when|which|is|are|does|do|did|can|could|should|would|will|explain|tell me|show me|summari[sz]e|describe|walk me through)\b/i;
+function isQuestion(line) {
+    return line.trim().endsWith("?") || QUESTION.test(line.trim());
+}
+export async function runApp() {
+    const gitOk = isGitRepo(process.cwd());
+    if (gitOk)
+        ensureInit();
+    printWelcome(gitOk);
+    let results = await connectAgents();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    if (await offerSetup(rl, results))
+        results = await connectAgents();
+    const prefs = readPrefs();
+    const state = { mode: prefs.mode ?? "manual", approvals: prefs.approvals ?? "auto" };
+    const save = () => writePrefs({ ...readPrefs(), mode: state.mode, approvals: state.approvals });
+    await offerChildRepo((l = "") => console.log(l), rl);
+    const ready = results.filter((r) => r.state === "ready").length;
+    console.log(C.faint(`\n${ready} of ${results.length} agents in the room. Type a goal, a question, or \`help\`.`));
+    const out = process.stdout;
+    const prompt = C.violet("huddle ›") + " ";
+    let promptShown = false; // prompt + footer are on screen and live
+    let asking = false; // a y/n question owns the line
+    const held = []; // output that arrived during a question
+    let run = null;
+    const queue = [];
+    let stats = null;
+    let ticker = null;
+    /** "⏱ 1m12s · ● claude 40s 31k · ● codex 22s 15k · ○ cursor" */
+    const liveStats = () => {
+        if (!stats)
+            return C.violet("● planning…");
+        const now = Date.now();
+        const parts = [...stats.agents].map(([id, a]) => a.busySince
+            ? `${dot(id)} ${id} ${fmtDuration(now - a.busySince)} ${C.faint(a.liveTokens < 0 ? "…" : fmtTokens(a.liveTokens) + " tok")}`
+            : C.faint(`○ ${id}`));
+        return `${C.faint("⏱")} ${fmtDuration(now - stats.startedAt)}  ${parts.join("  ")}`;
+    };
+    // Footer under the prompt, like Claude Code's mode line.
+    const footer = () => run
+        ? `  ${MODE_INFO[state.mode].chip}  ${liveStats()}${queue.length ? C.faint(`  · ${queue.length} queued`) : ""}`
+        : `  ${MODE_INFO[state.mode].chip} ${C.faint("· " + MODE_INFO[state.mode].desc)}   ` +
+            `${C.faint("approvals:")} ${state.approvals}   ${C.faint("shift+tab to switch")}`;
+    const drawFooter = () => {
+        if (!promptShown || asking || !out.isTTY)
+            return;
+        // Never wrap: a wrapped footer would break the cursor save/restore.
+        out.write("\x1b7\x1b[1B\r\x1b[2K" + truncate(footer(), (out.columns || 80) - 1) + "\x1b8");
+    };
+    const showPrompt = () => {
+        out.write("\n\x1b[1A"); // reserve the footer line below
+        rl.setPrompt(prompt);
+        rl.prompt(true);
+        promptShown = true;
+        drawFooter();
+    };
+    // The live view (ctrl-t / `view`). While it's up, prompt output waits.
+    const dash = new Dashboard({
+        db: () => live?.db ?? null,
+        stats: () => stats,
+        modeChip: () => MODE_INFO[state.mode].chip,
+    });
+    const openView = () => {
+        if (asking || !out.isTTY)
+            return;
+        promptShown = false;
+        dash.show(undefined, () => {
+            rl.write(null, { ctrl: true, name: "u" }); // drop keys typed into the view
+            for (const l of held.splice(0))
+                console.log(l);
+            showPrompt();
+        });
+    };
+    // Print above the live prompt, then redraw it with whatever was being typed.
+    const print = (line = "") => {
+        if (asking || dash.isOpen())
+            return void held.push(line);
+        if (!promptShown || !out.isTTY)
+            return void console.log(line);
+        out.write("\r\x1b[J"); // clear prompt + footer
+        console.log(line);
+        showPrompt();
+    };
+    questionHooks.before = () => {
+        if (dash.isOpen()) {
+            dash.hide();
+            for (const l of held.splice(0))
+                console.log(l);
+        }
+        if (promptShown && out.isTTY)
+            out.write("\r\x1b[J");
+        promptShown = false;
+        asking = true;
+    };
+    questionHooks.after = () => {
+        asking = false;
+        for (const l of held.splice(0))
+            console.log(l);
+        if (run)
+            showPrompt(); // back to the live prompt mid-run
+    };
+    process.stdin.on("keypress", (_s, key) => {
+        if (!key)
+            return;
+        if (key.ctrl && key.name === "t" && !asking && !dash.isOpen())
+            return void setImmediate(openView);
+        if (dash.isOpen())
+            return;
+        if (key.name === "tab" && key.shift && !asking) {
+            state.mode = MODES[(MODES.indexOf(state.mode) + 1) % MODES.length];
+            save();
+        }
+        setImmediate(drawFooter); // readline may have cleared below the prompt
+    });
+    rl.on("SIGINT", () => {
+        if (run) {
+            print(C.yellow("  stopping agents…"));
+            queue.length = 0;
+            run.abort();
+            return;
+        }
+        if (asking)
+            return;
+        if (rl.line) {
+            rl.write(null, { ctrl: true, name: "u" }); // clear the line, like a shell
+            return;
+        }
+        print(C.faint("  (type exit or press ctrl-d to leave)"));
+    });
+    rl.on("close", () => {
+        out.write("\r\x1b[J");
+        console.log(C.faint("bye 👋"));
+        process.exit(0); // the scheduler's exit hook stops any running agents
+    });
+    const setApprovals = async (arg) => {
+        const level = arg;
+        if (!(level in APPROVALS)) {
+            print();
+            for (const [k, v] of Object.entries(APPROVALS))
+                print(`  ${k === state.approvals ? C.violet("●") : C.faint("○")} ${pad(C.bold(k), 6)} ${C.faint(v)}`);
+            print(C.faint("\n  set with: approvals safe | auto | yolo" + (run ? " — applies to agents that start after this" : "")));
+            return;
+        }
+        if (level === "yolo" && state.approvals !== "yolo") {
+            print(C.yellow("\n  yolo lets agents run any command on this machine without a sandbox."));
+            if (!(await yes(rl, "  Turn it on?", false)))
+                return;
+        }
+        state.approvals = level;
+        save();
+        print(`  ${C.green("✓")} approvals: ${level} ${C.faint("· " + APPROVALS[level] + (run ? " (from the next agent that starts)" : ""))}`);
+    };
+    // ---- the long-lived Room + multiplayer --------------------------------
+    let live = null;
+    let tunnel = null;
+    let relayLink = null;
+    let funnel = null;
+    /** The Room for the current repo, opened once and kept for the session. */
+    const openRoom = async () => {
+        if (!isGitRepo(process.cwd()))
+            return null;
+        const root = repoRoot();
+        if (live?.root === root)
+            return live;
+        closeRoom();
+        ensureInit();
+        const db = new RoomDB(dbPath());
+        const r0 = remoteInfo(root);
+        const server = await startRoom(db, ROOM_PORT, {
+            remote: r0 ? canonicalRemote(r0.url) : undefined,
+            branch: r0?.branch,
+            host: githubUser() ?? os.userInfo().username,
+        });
+        // huddle_ask: answer agents' questions from shared memory, with the brain.
+        server.answerer = async (question) => {
+            const mem = db.recall().slice(0, 60);
+            if (!mem.length)
+                return "";
+            const brain = resolveBrain(results);
+            if (!brain)
+                return mem.find((m) => question.split(/\W+/).some((w) => w.length > 3 && m.body.includes(w)))?.body ?? "";
+            const r = await brain.think(`An agent on the team asked: "${question}"\nAnswer ONLY from this shared memory (decisions and facts other agents recorded). ` +
+                `One or two sentences, quote exact names/shapes. If the memory doesn't say, reply exactly: UNKNOWN\n\n` +
+                mem.map((m) => `- (${m.author}) ${m.body}${m.why ? " — why: " + m.why : ""}`).join("\n"), root, { selfContained: true, timeoutMs: 60_000 });
+            return r.ok && !/^UNKNOWN/i.test(r.text.trim()) ? r.text.trim() : "";
+        };
+        const unsub = db.onEvent((e) => {
+            const p = JSON.parse(e.payload || "{}");
+            if (e.type === "member.joined")
+                print(`  ${C.green("●")} ${C.bold(p.name)} joined the room ${C.faint("· " + p.role)}`);
+            if (e.type === "member.left")
+                print(`  ${C.faint("○")} ${C.bold(p.name)} ${p.reason === "removed" ? "was removed" : "left"}`);
+            if (e.type === "message")
+                dash.push({ text: `${C.violet("💬")} ${C.bold(p.from)} ${C.faint("›")} ${p.body}` });
+            if (e.type === "ask")
+                dash.push({ text: `${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${p.to ?? "room"}  ${p.question}` });
+            if (e.type === "answer" && p.source !== "teammate")
+                dash.push({ text: `${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${p.to}  ${p.answer} ${C.faint("— from shared memory")}` });
+            if (e.type === "member.joined")
+                dash.push({ text: `${C.green("●")} ${p.github ? "@" + p.github : p.name} joined` });
+            if (e.type === "message")
+                print(`  ${C.violet("💬")} ${C.bold(p.from)} ${C.faint("›")} ${p.body}`);
+            if (e.type === "crew.updated")
+                print(`  ${C.faint("⚡")} ${C.bold(p.member)}'s crew: ${p.agents.map((a) => dot(a) + " " + a).join("  ")}`);
+            if (e.type === "ask")
+                print(`  ${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${p.to ? dot(p.to) + " " + C.bold(p.to) : C.faint("room")}  ${p.question}`);
+            // A teammate's own answer already showed as their message.
+            if (e.type === "answer" && p.source !== "teammate")
+                print(`  ${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${C.bold(p.to)}  ${p.answer} ${C.faint("— from shared memory")}`);
+        });
+        live = { db, server, root, unsub };
+        return live;
+    };
+    const closeRoom = () => {
+        if (!live)
+            return;
+        live.unsub();
+        live.server.close();
+        live.db.close();
+        live = null;
+        tunnel?.close();
+        tunnel = null;
+        relayLink?.close();
+        relayLink = null;
+        funnel?.close();
+        funnel = null;
+    };
+    process.once("exit", closeRoom);
+    const invite = async (arg) => {
+        const r = await openRoom();
+        if (!r)
+            return print(C.red("  ✗ open a git repo first") + C.faint(" — a room belongs to a project"));
+        // `invite @harsh` = only GitHub user harsh can use it (proved with their SSH key).
+        // `invite @harsh guest` = they can watch and message, not work.
+        const words = arg.split(/\s+/).filter(Boolean);
+        const role = words.includes("guest") ? "guest" : "member";
+        const handle = words.find((w) => w.startsWith("@"))?.slice(1);
+        const name = handle ?? words.find((w) => w !== "guest") ?? "";
+        if (handle) {
+            const repo = r.server.info.remote ? githubRepo(r.server.info.remote) : null;
+            if (repo) {
+                const collab = isCollaborator(repo, handle);
+                if (collab === false) {
+                    print(C.yellow(`\n  @${handle} can't access ${repo} on GitHub, so they couldn't pull or push the code.`));
+                    if (await yes(rl, `  Add @${handle} as a collaborator on ${repo}? (sends them a GitHub invite)`, false)) {
+                        const add = spawnSync("gh", ["api", "-X", "PUT", `repos/${repo}/collaborators/${handle}`, "-f", "permission=push"], {
+                            encoding: "utf8",
+                        });
+                        print(add.status === 0 ? `  ${C.green("✓")} GitHub invite sent to @${handle}` : C.red(`  ✗ ${add.stderr.trim().split("\n")[0]}`));
+                    }
+                }
+                else if (collab)
+                    print(C.faint(`  @${handle} has access to ${repo} ✓`));
+            }
+        }
+        // Relay first (works across any networks); direct door as a fallback.
+        const relayUrl = readPrefs().relay;
+        if (relayUrl && !relayLink)
+            relayLink = await openRelayLink(r.server, relayUrl, print);
+        const { port, lanUrls } = await r.server.share();
+        // Tailscale Funnel: a public https address, no server. Asked once.
+        let fPref = readPrefs().funnel;
+        if (!relayLink && !funnel && fPref !== false) {
+            if (fPref === undefined) {
+                print(C.faint("\n  Tailscale Funnel can give this room a public https address, so teammates on any network can join."));
+                print(C.faint("  Only the shared door is exposed; it still needs an invite code (and their GitHub key for @invites)."));
+                fPref = await yes(rl, "  Use Funnel for invites?");
+                writePrefs({ ...readPrefs(), funnel: fPref });
+            }
+            if (fPref) {
+                const f = openFunnel(port);
+                if (f.ok)
+                    funnel = f;
+                else
+                    print(C.yellow(`  ! Funnel: ${f.reason}`) + C.faint(" — using the other routes for now"));
+            }
+        }
+        if (!tunnel && !relayLink && !funnel) {
+            tunnel = await openTunnel(port, print);
+        }
+        const { code, expiresAt } = r.db.createInvite({ forName: name || undefined, github: handle, role });
+        // Best reachable address first: public tunnel → your tailnet → this Wi-Fi.
+        const ts = tailscaleIp();
+        const routes = [];
+        if (relayLink)
+            routes.push([relayLink.address, "from anywhere, via your relay"]);
+        if (funnel)
+            routes.push([funnel.url, "from anywhere, via Tailscale Funnel"]);
+        if (tunnel)
+            routes.push([tunnel.url, "from anywhere"]);
+        if (ts)
+            routes.push([`http://${ts}:${port}`, "anyone on your Tailscale network"]);
+        for (const u of lanUrls)
+            if (!ts || !u.includes(ts))
+                routes.push([u, "same Wi-Fi only"]);
+        if (!routes.length)
+            routes.push([`http://127.0.0.1:${port}`, "this machine only"]);
+        const who = handle ? `for @${handle} (GitHub-verified) ` : name ? `for ${name} ` : "";
+        print(`\n  ${C.violet("invite")} ${C.faint(who + "· " + role + " · one use · expires " + new Date(expiresAt).toLocaleTimeString())}`);
+        print(`\n    ${C.bold(`huddle join ${routes[0][0]} ${code}`)}   ${C.faint(routes[0][1])}`);
+        for (const [u, why] of routes.slice(1))
+            print(C.faint(`    or: huddle join ${u} ${code}   ${why}`));
+        print();
+        if (!tunnel && !ts && !relayLink && !funnel)
+            print(C.faint("  tip: for teammates on other networks, set a relay (`relay <url>`) or run Tailscale on both machines"));
+        print(C.faint("  macOS may ask to let node accept incoming connections — allow it for invites to work"));
+        if (!handle)
+            print(C.faint("  tip: `invite @github-user` so only that person can use it"));
+        print(C.faint(role === "guest"
+            ? "  guests watch the board and message the room"
+            : "  members bring their crew: their agents take tasks, work in their own clone, and push branches you merge"));
+        print(C.faint("  nobody can run anything on your machine"));
+    };
+    const members = () => {
+        const list = live?.db.listMembers() ?? [];
+        if (!list.length)
+            return print(C.faint("  just you — `invite` someone"));
+        for (const m of list)
+            print(`  ${C.green("●")} ${pad(C.bold(m.name), 16)} ${C.faint(m.role + " · joined " + new Date(m.joined_at).toLocaleTimeString())}`);
+    };
+    const removeMember = (name) => {
+        const m = live?.db.listMembers().find((x) => x.name.toLowerCase() === name.toLowerCase() || x.id === name);
+        if (!m)
+            return print(C.faint(`  no member called ${name}`));
+        live.db.removeMember(m.id, "removed");
+    };
+    const setBrain = async (arg) => {
+        const ready = results.filter((r) => r.state === "ready").map((r) => r.adapter.id);
+        if (!arg) {
+            const current = resolveBrain(results);
+            print(`\n  ${C.faint("Huddle's own thinking (planning, reports, answers) runs on:")} ${C.bold(current?.label ?? "nothing ready")}`);
+            print(C.faint("  Agents still write the code with their own models. Options:\n"));
+            for (const o of await brainOptions(ready))
+                print(`  ${o.spec === current?.spec ? C.violet("●") : C.faint("○")} ${pad(C.bold(o.spec), 28)} ${C.faint(o.note)}`);
+            print(C.faint("\n  set with: brain <spec>   e.g. brain ollama:qwencoder · brain cursor:grok-4.7-low-fast · brain claude:haiku"));
+            return;
+        }
+        const kind = arg.split(":")[0];
+        const b = brainFrom(arg);
+        if (!b)
+            return print(C.red(`  ✗ don't know "${arg}"`) + C.faint(" — try `brain` for options"));
+        if (kind === "ollama" && !(await ollamaModels()).includes(arg.split(":").slice(1).join(":")))
+            return print(C.red(`  ✗ Ollama doesn't have ${arg.slice(7)}`) + C.faint(" — `ollama pull <model>` first"));
+        if (kind !== "ollama" && !ready.includes(kind))
+            return print(C.red(`  ✗ ${kind} isn't ready`) + C.faint(" — type `agents`"));
+        writePrefs({ ...readPrefs(), brain: arg });
+        print(`  ${C.green("✓")} brain: ${b.label}`);
+    };
+    const setCrew = (arg) => {
+        const ready = results.filter((r) => r.state === "ready").map((r) => r.adapter.id);
+        const crew = { ...(readPrefs().crew ?? {}) };
+        if (arg) {
+            for (const part of arg.split(/[\s,]+/)) {
+                const m = /^([a-z]+)\s*[=x×:]\s*(\d+)$/i.exec(part);
+                if (!m || !ready.includes(m[1].toLowerCase()))
+                    return print(C.red(`  ✗ didn't understand "${part}"`) + C.faint(" — e.g. crew claude=2 codex=1"));
+                crew[m[1].toLowerCase()] = Math.min(4, Number(m[2]));
+            }
+            writePrefs({ ...readPrefs(), crew });
+        }
+        const workers = workersFrom(results);
+        print(`\n  ${C.faint("crew:")} ${ready.map((id) => `${dot(id)} ${id} ×${crew[id] ?? 1}`).join("   ")}`);
+        print(C.faint(`  ${workers.length} agent${workers.length === 1 ? "" : "s"} per run · max 4 of each · 0 benches an agent`));
+    };
+    const shell = (cmd) => {
+        promptShown = false;
+        out.write("\r\x1b[J");
+        rl.pause();
+        spawnSync("sh", ["-c", cmd], { stdio: "inherit" });
+        rl.resume();
+    };
+    const startGoal = async (typed) => {
+        // "--qa" / "--no-qa" anywhere in a typed goal, like on `huddle join`.
+        const qa = /(^|\s)--no-qa(\s|$)/.test(typed) ? false : /(^|\s)--qa(\s|$)/.test(typed) ? true : undefined;
+        const goal = typed.replace(/(^|\s)--(no-)?qa(?=\s|$)/g, " ").trim();
+        run = new AbortController();
+        stats = null;
+        ticker = setInterval(drawFooter, 1000); // keep the timers ticking
+        drawFooter();
+        try {
+            const r = await openRoom();
+            await runGoal(goal, {
+                results,
+                mode: state.mode,
+                approvals: state.approvals,
+                rl,
+                signal: run.signal,
+                print,
+                onStats: (s) => (stats = s),
+                room: r ?? undefined,
+                onActivity: (a) => dash.push(a),
+                qa,
+            });
+        }
+        catch (e) {
+            print(C.red("  error: ") + (e?.message ?? e));
+        }
+        finally {
+            run = null;
+            stats = null;
+            if (ticker)
+                clearInterval(ticker);
+            ticker = null;
+            const next = queue.shift();
+            if (next) {
+                print(C.violet(`\n▸ next in queue: `) + next);
+                void startGoal(next);
+            }
+            else
+                drawFooter();
+        }
+    };
+    rl.on("line", async (raw) => {
+        if (dash.isOpen())
+            return; // keys typed into the live view aren't commands
+        const line = raw.trim();
+        promptShown = false;
+        out.write("\x1b[2K"); // clear the footer line we just moved onto
+        if (!line)
+            return showPrompt();
+        const [cmd, ...rest] = line.split(/\s+/);
+        const arg = rest.join(" ").replace(/^["']|["']$/g, "");
+        let background = false;
+        try {
+            if (cmd === "exit" || cmd === "quit")
+                return rl.close();
+            if (cmd === "help" || cmd === "?")
+                print(HELP);
+            else if (cmd === "clear" || cmd === "cls") {
+                out.write("\x1b[2J\x1b[3J\x1b[H");
+            }
+            else if (cmd === "approvals")
+                await setApprovals(arg);
+            else if (cmd === "board")
+                printBoard(print);
+            else if (cmd === "view") {
+                setImmediate(openView);
+                background = true;
+            }
+            else if (cmd === "brain")
+                await setBrain(arg);
+            else if (cmd === "invite")
+                await invite(arg);
+            else if (cmd === "funnel") {
+                if (arg === "on" || arg === "off")
+                    writePrefs({ ...readPrefs(), funnel: arg === "on" });
+                if (arg === "off") {
+                    funnel?.close();
+                    funnel = null;
+                }
+                const on = readPrefs().funnel;
+                print(`  funnel ${on ? C.green("on") : on === false ? C.faint("off") : C.faint("not set — asked on your first invite")}${funnel ? C.faint(" · live at " + funnel.url) : ""}`);
+            }
+            else if (cmd === "relay") {
+                if (arg === "off")
+                    writePrefs({ ...readPrefs(), relay: undefined });
+                else if (arg) {
+                    if (!/^(wss?|https?):\/\//.test(arg))
+                        print(C.red("  ✗ give a URL, e.g. relay wss://relay.example.com"));
+                    else
+                        writePrefs({ ...readPrefs(), relay: arg.replace(/^http/, "ws") });
+                }
+                const cur = readPrefs().relay;
+                print(`  relay ${cur ? C.bold(cur) : C.faint("off — invites use Tailscale / Wi-Fi / tunnel")}`);
+            }
+            else if (cmd === "sync") {
+                if (!isGitRepo(process.cwd()))
+                    print(C.faint("  not a git repo"));
+                else {
+                    const root = repoRoot();
+                    const r = remoteInfo(root);
+                    if (arg === "on" || arg === "off")
+                        writeRepoConfig(root, { sync: arg === "on" });
+                    const on = readRepoConfig(root).sync;
+                    print(`  sync ${on ? C.green("on") : C.faint("off")} ${C.faint(r ? "· " + r.name + " " + r.url : "· no remote — add one with git remote add origin <url>")}`);
+                }
+            }
+            else if (cmd === "members")
+                members();
+            else if (cmd === "remove" || cmd === "kick")
+                removeMember(arg);
+            else if (cmd === "crew") {
+                if (run)
+                    print(C.faint("  applies to the next run"));
+                setCrew(arg);
+            }
+            else if (cmd === "stop") {
+                if (run) {
+                    queue.length = 0;
+                    run.abort();
+                    print(C.yellow("  stopping agents…"));
+                }
+                else
+                    print(C.faint("  nothing running"));
+            }
+            else if (cmd === "agents") {
+                if (run)
+                    print(C.faint("  finish or stop the current run first"));
+                else {
+                    results = await connectAgents();
+                    if (await offerSetup(rl, results, true))
+                        results = await connectAgents();
+                }
+            }
+            else if (cmd === "cd") {
+                if (run)
+                    print(C.faint("  finish or stop the current run first"));
+                else {
+                    const to = path.resolve(process.cwd(), arg.replace(/^~(?=$|\/)/, os.homedir()) || os.homedir());
+                    if (live?.db.listMembers().length)
+                        print(C.yellow("  note: people in this room are disconnected when you switch projects"));
+                    try {
+                        process.chdir(to);
+                        if (live && live.root !== repoRoot())
+                            closeRoom();
+                        const ok = isGitRepo(process.cwd());
+                        if (ok)
+                            ensureInit();
+                        print(`  ${C.faint("cwd")} ${tildify(process.cwd())}${ok || childRepos().length ? "" : C.faint("  · not a git repo yet — Huddle will offer to set it up when you give it a goal")}`);
+                        if (!ok)
+                            await offerChildRepo(print, rl);
+                    }
+                    catch {
+                        print(C.red(`  ✗ no such folder: ${arg}`));
+                    }
+                }
+            }
+            else if (line.startsWith("!"))
+                shell(line.slice(1));
+            else if (SHELL_WORDS.has(cmd)) {
+                shell(line);
+                print(C.faint(`  (ran as a shell command — say "build ${line}" if you meant a goal)`));
+            }
+            else if (cmd === "ask" || (cmd !== "build" && cmd !== "join" && isQuestion(line))) {
+                await answer(print, cmd === "ask" ? arg : line, results);
+            }
+            else {
+                const goal = cmd === "build" || cmd === "join" ? arg : line;
+                if (!goal)
+                    print(C.faint("  usage: build <goal>"));
+                else if (run) {
+                    queue.push(goal);
+                    print(`  ${C.violet("+")} queued ${C.faint("· starts when the current run finishes (" + queue.length + " in queue)")}`);
+                }
+                else {
+                    background = true;
+                    void startGoal(goal);
+                }
+            }
+        }
+        catch (e) {
+            print(C.red("  error: ") + (e?.message ?? e));
+        }
+        finally {
+            if (!background || !asking)
+                showPrompt();
+        }
+    });
+    showPrompt();
+}
+//# sourceMappingURL=app.js.map