huddle-cli 0.1.0 → 0.1.3

package/dist/ui/app.js

@@ -15,7 +15,8 @@ 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 { ADAPTERS, applySkips, installCommand, noInstallHint, probeAsync } from "../adapters/index.js";
+import { gitFix, runShell, spawnToolSync } from "../platform.js";
 import { RoomDB } from "../room/db.js";
 import { startRoom } from "../room/server.js";
 import { openFunnel, openTunnel, tailscaleIp } from "../room/tunnel.js";
@@ -23,17 +24,27 @@ 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 { councilMembers, councilWanted, headline, pastSyntheses, recordCouncil, runCouncil } from "../orchestrator/council.js";
+import { contractFile } from "../room/contract.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 { QA_ROUNDS, runQa, shouldQa } from "../orchestrator/qa.js";
+import { Budget, HARD_AT, SOFT_AT, budgetFlag, budgetNotes, budgetUse, costPreview, parseTokens, runHistory } from "../orchestrator/budget.js";
+import { commitFile, isGitRepo, listWorktrees, removeWorktree, worktreeFor } from "../sandbox/worktree.js";
+import { C, Dock, LiveLines, box, dot, fit, lineWidth, pad, truncate, width, wrap } from "./term.js";
 import { AGENTS_FILE_ERRORS, LEGACY } from "../adapters/index.js";
 import { logoLines } from "./logo.js";
-import { Dashboard } from "./dashboard.js";
+import { Dashboard, estHint, progressLine, taskCounts, taskMeter } from "./dashboard.js";
+import { learnFromRun } from "../orchestrator/learn.js";
+import { briefLines, liftPointers, placePointers, writeBrief } from "./brief.js";
+import { PasteCatcher, addPaths, asDrop, bracketedPaste, ctxCommand, flatten, interceptStdin, isLongPaste, looksLikePaths, pasteToScreen, screenEvent } from "./paste.js";
+import { splitPathTokens } from "../room/context.js";
+import { narration, narratorLine } from "./narrator.js";
+import { clearCommands, openApp, saveReport, takeCommands, writeLive } from "../app/live.js";
+import { KeyLine, Talk, addressee, questionLines, settledLine } from "./talk.js";
+import { sayToAgents, USER_ID } from "../room/user.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 ----------------------------------------------------------
@@ -80,8 +91,8 @@ export function detectTestCmd(root) {
     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.
+ * The brain to use: your pick if it's usable, else Claude Opus (the strongest
+ * plans — the brain writes every task spec), 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);
@@ -95,23 +106,46 @@ export function resolveBrain(results, probed = results) {
             return b;
     }
     if (ready.includes("claude"))
-        return brainFrom("claude:sonnet");
+        return brainFrom("claude:opus");
     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");
+// (Read per call, so a test can point HUDDLE_HOME somewhere else.)
+const prefsFile = () => path.join(process.env.HUDDLE_HOME ?? path.join(os.homedir(), ".huddle"), "prefs.json");
 export function readPrefs() {
     try {
-        return JSON.parse(fs.readFileSync(PREFS, "utf8"));
+        return JSON.parse(fs.readFileSync(prefsFile(), "utf8"));
     }
     catch {
         return {};
     }
 }
-function writePrefs(p) {
-    fs.mkdirSync(path.dirname(PREFS), { recursive: true });
-    fs.writeFileSync(PREFS, JSON.stringify(p, null, 2));
+export function writePrefs(p) {
+    fs.mkdirSync(path.dirname(prefsFile()), { recursive: true });
+    fs.writeFileSync(prefsFile(), JSON.stringify(p, null, 2));
+}
+/** The agents you skipped (`huddle agents skip <id>`). */
+export function skippedAgents() {
+    return new Set(readPrefs().skip ?? []);
+}
+/**
+ * Use or skip agents, remembered in prefs. Using one also forgets an old
+ * "don't install" answer, so Huddle offers it again.
+ */
+export function setAgentChoice(ids, use) {
+    const p = readPrefs();
+    const skip = new Set(p.skip ?? []);
+    const declined = new Set(p.declinedInstall ?? []);
+    for (const id of ids) {
+        if (use) {
+            skip.delete(id);
+            declined.delete(id);
+        }
+        else
+            skip.add(id);
+    }
+    writePrefs({ ...p, skip: [...skip], declinedInstall: [...declined] });
 }
 // ---- welcome ---------------------------------------------------------------
 function tildify(p) {
@@ -167,16 +201,24 @@ export async function connectAgents() {
             return `  ${C.green("✓")} ${head}  ready`;
         if (r.state === "not_installed")
             return `  ${C.faint("○")} ${head}  ${C.faint("not installed")}`;
+        if (r.state === "skipped")
+            return `  ${C.faint("–")} ${head}  ${C.faint(r.detail)}`;
         return `  ${C.yellow("!")} ${head}  ${C.yellow("not signed in")} ${C.faint("— " + r.detail)}`;
     };
+    const skip = skippedAgents();
+    const probeOne = async (a) => applySkips([await probeAsync(a)], skip)[0];
     // 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);
+        results.set(a.id, await probeOne(a));
+    const shownLegacy = (a) => {
+        const r = results.get(a.id);
+        return r?.state === "ready" || (r?.state === "skipped" && r.was === "ready");
+    };
+    const visible = ADAPTERS.filter((a) => shown(a) || (LEGACY.has(a.id) && shownLegacy(a)));
     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));
+            results.set(a.id, await probeOne(a));
         live.draw();
     }));
     live.stop();
@@ -199,21 +241,52 @@ async function yes(rl, q, def = true) {
         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();
+/**
+ * Run a command with the terminal handed over (installers, logins). A string
+ * is a shell line — sh, or PowerShell on Windows (`irm … | iex`); an array is
+ * a CLI, spawned without a shell.
+ */
+export function runInteractive(rl, cmd) {
+    rl?.pause();
+    bracketedPaste(false); // the other program gets a plain terminal
+    const r = typeof cmd === "string" ? runShell(cmd) : spawnToolSync(cmd, { stdio: "inherit" });
+    bracketedPaste(true);
+    rl?.resume();
     return r.status === 0;
 }
+function rlIO(rl) {
+    return { ask: (q, def) => yes(rl, q, def), run: (cmd) => runInteractive(rl, cmd), print: (l = "") => console.log(l) };
+}
+/** Install one agent's CLI with this platform's command. False if it failed or there's none. */
+export function installAgent(io, a) {
+    const cmd = installCommand(a);
+    if (!cmd) {
+        io.print(C.yellow(`  ${a.id}: `) + C.faint(noInstallHint(a)));
+        return false;
+    }
+    io.print(C.violet(`\n↓ installing ${a.id}…`) + C.faint(`  $ ${cmd}`));
+    const ok = io.run(cmd);
+    io.print(ok ? C.green(`✓ ${a.id} installed`) : C.red(`✗ ${a.id} install failed — see output above`));
+    return ok;
+}
+/** Hand the terminal to an agent's own sign-in. False if it has no login command. */
+export function signIn(io, a) {
+    if (!a.install.login)
+        return false;
+    if (a.install.loginNote)
+        io.print(C.faint(`  ${a.install.loginNote}`));
+    io.run(a.install.login);
+    return true;
+}
+/** The install line to show for an agent on this platform. */
+export const installLine = (a) => installCommand(a) ?? noInstallHint(a);
 /**
  * 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 io = rlIO(rl);
     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));
@@ -222,19 +295,14 @@ export async function offerSetup(rl, results, force = 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)}`);
+            console.log(`  ${dot(r.adapter.id)} ${C.bold(r.adapter.id)}  ${C.faint(installCommand(r.adapter) ? "$ " + installLine(r.adapter) : installLine(r.adapter))}`);
         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`));
+                const ok = installAgent(io, r.adapter);
                 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);
-                }
+                if (ok && r.adapter.install.login && (await yes(rl, `Sign in to ${r.adapter.id} now?`)))
+                    signIn(io, r.adapter);
             }
         }
         else {
@@ -247,9 +315,7 @@ export async function offerSetup(rl, results, force = false) {
         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);
+            signIn(io, r.adapter);
             changed = true;
         }
         else {
@@ -259,6 +325,50 @@ export async function offerSetup(rl, results, force = false) {
     }
     return changed;
 }
+/**
+ * The live status block under the run's output, one line per agent:
+ *   ● claude   ████░░  60%  Build the CLI adapter     · note 20s ago · 1m12s
+ *   ● codex    ······   —   Build the HTTP API        · no report yet · 3m20s
+ *   ○ cursor   idle · 2 merged
+ * The bar is the agent's own last huddle_progress %, never a guess. Every line
+ * fits `W` cells: the bar goes first on a narrow screen, then the title gives
+ * way, never the numbers.
+ */
+export function statusLines(stats, W, now = Date.now()) {
+    const idW = Math.min(12, Math.max(6, ...[...stats.agents.keys()].map((id) => id.length)));
+    return [...stats.agents].map(([id, a]) => {
+        const head = `  ${a.busySince ? dot(id) : C.faint("○")} ${pad(id, idW)} `;
+        if (!a.busySince) {
+            const done = a.tasks + a.reviews + (a.qa ?? 0);
+            return head + C.faint(done ? `idle · ${a.tasks} merged${a.reviews ? `, ${a.reviews} reviewed` : ""}` : "idle");
+        }
+        const quiet = a.noteAt === undefined ? now - a.busySince : now - a.noteAt;
+        const said = a.noteAt === undefined ? "no report yet" : `note ${fmtDuration(now - a.noteAt)} ago`;
+        const est = estHint(a.est, now - a.busySince);
+        const meter = taskMeter(a.pct ?? null, W >= 100 ? 8 : W >= 70 ? 6 : 0);
+        const base = (quiet > 120_000 ? C.yellow(` · ${said}`) : C.faint(` · ${said}`)) +
+            C.faint(` · ${fmtDuration(now - a.busySince)}${a.liveTokens > 0 ? ` · ${fmtTokens(a.liveTokens)} tok` : ""}`);
+        // The estimate is a hint: it goes before the title would have to drop under 8 cells.
+        const withEst = est ? base + C.faint(" · ") + est : base;
+        const tail = W - width(head) - width(meter) - 1 - width(withEst) >= 8 ? withEst : base;
+        const room = Math.max(8, W - width(head) - width(meter) - 1 - width(tail));
+        return truncate(`${head}${meter} ${pad(truncate(a.doing ?? "working", room), Math.min(room, 34))}${tail}`, W);
+    });
+}
+/**
+ * The pinned block during a run: the overall bar, then (once agents are on tasks) a status line each.
+ *   BUILD ███████░░░░░ 6/9 tasks · 12m03s
+ *   ● claude   ████░░  60%  Build the CLI adapter · note 20s ago · 1m12s
+ */
+export function runLines(stats, W, now = Date.now()) {
+    const r = stats.run;
+    const top = r ? `  ${progressLine(r, now - stats.startedAt, W - 2)}` : C.faint(`  ⏱ ${fmtDuration(now - stats.startedAt)}`);
+    return [top, ...(!r || r.phase === "BUILD" || r.phase === "QA" ? statusLines(stats, W, now) : [])];
+}
+/** The pinned block with the narrator on top: what's happening now in plain words, and whether you're needed. */
+export function liveLines(stats, W, now = Date.now()) {
+    return [narratorLine(stats, W, now), ...runLines(stats, W, now)];
+}
 export function newStats(workers) {
     return {
         startedAt: Date.now(),
@@ -340,7 +450,7 @@ async function prepareRepo(print, rl, goal = "") {
         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"));
+            print(C.red("  ✗ git isn't installed.") + C.faint(" " + gitFix()));
             return false;
         }
         const gi = path.join(process.cwd(), ".gitignore");
@@ -358,7 +468,8 @@ async function prepareRepo(print, rl, goal = "") {
         print(`  ${C.green("✓")} git repo ready`);
     }
     ensureInit();
-    const dirty = git(["status", "--porcelain"]).out.split("\n").filter((l) => l && !l.includes(".huddle/"));
+    liftPointers(repoRoot()); // the brief's pointer is out of CLAUDE.md / AGENTS.md while the team works (ui/brief.ts)
+    const dirty = git(["status", "--porcelain"]).out.split(/\r?\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.`));
@@ -423,23 +534,68 @@ export function likelyAgents(tasks, workers) {
     }
     return out;
 }
-function printPlan(print, goal, plan, workers) {
+/** Room left on a line once its fixed parts are drawn: the terminal's width, or 120 in a log. */
+const rawSpace = (...used) => (lineWidth() ?? 120) - used.reduce((n, u) => n + width(u), 0);
+const space = (...used) => Math.max(24, rawSpace(...used));
+/**
+ * A phase header. Every run reads the same way, top to bottom:
+ *   ━━ COUNCIL ━━  →  ━━ PLAN ━━  →  ━━ BUILD ━━  →  ━━ QA ━━  →  ━━ RESULT ━━
+ */
+function phase(print, name, sub = "") {
+    const head = `${C.violet("━━")} ${C.bold(C.violet(name))} ${C.violet("━━")}`;
+    // Cut to the terminal; a log keeps the whole line.
+    const rest = sub ? " " + C.faint(lineWidth() ? oneLine(sub, space(head, " ")) : sub) : "";
+    print(`\n${head}${rest}`);
+}
+const plural = (k, one) => `${k} ${k === 1 ? one : one + "s"}`;
+function printPlan(print, goal, plan, workers, verbose = process.env.HUDDLE_VERBOSE === "1", canType = false) {
     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 : ""))}`);
+    phase(print, "PLAN", `${plan.tasks.length} task(s) · by ${plan.by}${took}${plan.note ? " — " + plan.note : ""}`);
+    // First, in plain words: what this run makes and what using it looks like (the planner's "plain").
+    for (const l of plainLines(goal, plan))
+        print(l);
+    print(C.faint("  who does what:"));
     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}`);
+        // Whose idea it was is in TEAMWORK and huddle story; here it only pushed the title off the screen.
+        const idea = verbose && t.from?.length ? C.faint(`  · idea: ${t.from.join(", ")}`) : "";
+        const who = fit ? `  ${C.faint("→")} ${dot(fit)} ${fit}` : "";
+        const num = `  ${C.faint(String(i + 1).padStart(2) + ".")} `;
+        print(`${num}${oneLine(t.title, space(num, after, who, idea))}${after}${who}${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.
+    // The council's agreements, which every agent can huddle_recall mid-task. For the
+    // person watching they're engineering detail: one line, the rest on request.
+    const d = plan.council?.decisions?.length ?? 0;
+    const r = plan.council?.risks?.length ?? 0;
+    if (verbose)
+        for (const l of planDetails(plan))
+            print(l);
+    else if (d || r)
+        print(`  ${C.violet("◆")} ${C.faint(`the agents agreed ${[d ? plural(d, "technical decision") : "", r ? `${plural(r, "risk")} to watch` : ""].filter(Boolean).join(" and ")} · `)}${canType ? `type ${C.bold("details")}` : C.bold("huddle story")}${C.faint(canType ? " to read them" : " has them")}`);
+}
+/** "  What you'll get: …" / "  For example: …" — the plan for someone who isn't a programmer. */
+export function plainLines(goal, plan) {
+    // No summary from the planner (a template plan, an older brain): the goal as you typed it.
+    if (!plan.plain?.what)
+        return [`  ${C.faint("goal:")} ${oneLine(goal, space("  goal: "))}`];
+    const label = (s) => `  ${C.bold(pad(s, 15))} `;
+    const out = [`${label("What you'll get")}${oneLine(plan.plain.what, space(label("What you'll get")))}`];
+    if (plan.plain?.example)
+        out.push(`${label("For example")}${oneLine(plan.plain.example, space(label("For example")))}`);
+    return out;
+}
+/** The council's decisions and risks in full, for `details` (and HUDDLE_VERBOSE=1). */
+export function planDetails(plan) {
+    const out = [];
     for (const d of plan.council?.decisions ?? [])
-        print(`  ${C.violet("◆")} ${C.faint("decided:")} ${oneLine(d, 110)}`);
+        out.push(`  ${C.violet("◆")} ${C.faint("decided:")} ${d}`);
     for (const r of plan.council?.risks ?? [])
-        print(`  ${C.yellow("!")} ${C.faint("risk" + (r.by ? ` (${r.by})` : "") + ":")} ${oneLine(r.body, 105)}`);
+        out.push(`  ${C.yellow("!")} ${C.faint("risk" + (r.by ? ` (${r.by})` : "") + ":")} ${r.body}`);
+    return out;
 }
 /** Show a spinner line while a promise settles (TTY only). */
 async function withSpinner(label, p) {
@@ -455,13 +611,38 @@ async function withSpinner(label, p) {
         process.stdout.write("\x1b[1A\x1b[2K"); // remove the spinner line
     }
 }
+/** A run, and the brief's pointers put back however it ended (plan mode, a stop, a crash). */
+/** The current run's typing line and open questions, closed however the run ends (a throw included). */
+let endTalkNow = null;
 export async function runGoal(goal, opts) {
-    const print = opts.print ?? ((l = "") => console.log(l));
+    try {
+        await runGoalOnce(goal, opts);
+    }
+    finally {
+        endTalkNow?.();
+        endTalkNow = null;
+        if (isGitRepo(process.cwd()))
+            placePointers(repoRoot(), { enabled: readPrefs().brief !== false });
+    }
+}
+async function runGoalOnce(goal, opts) {
+    // Every line fits the terminal (logs keep everything). In a one-shot run on a
+    // terminal, the per-agent status lines sit under the output (the Dock).
+    let dock = null;
+    const sink = opts.print ?? ((l = "") => (dock ? dock.log(l) : console.log(l)));
+    const print = (l = "") => sink(fit(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);
+    // --budget=5M, typed at the prompt too. Past 90% no new work starts; past 120% the agents stop (budget.ts).
+    const typedBudget = budgetFlag(goal);
+    goal = typedBudget.goal;
+    const budgetAsked = opts.budget ?? typedBudget.budget ?? readPrefs().budget;
+    const budget = new Budget(budgetAsked === undefined ? null : parseTokens(budgetAsked));
+    if (budgetAsked !== undefined && !budget.limit)
+        print(C.yellow(`  ! --budget=${budgetAsked} isn't a token count (try 5M or 800k) — no budget this run`));
     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) {
@@ -481,54 +662,326 @@ export async function runGoal(goal, opts) {
     // 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 }));
+    // The run's live numbers from its first step: the per-agent status lines and the overall bar.
+    const stats = newStats([...workers, ...remoteNow()].map((w) => w.id));
+    let board = null; // this run's Room, once its board is seeded: the bar counts its tasks
+    let logged = ""; // the last progress line a log got
+    const progress = (p) => {
+        let counts = {};
+        try {
+            if (board)
+                counts = taskCounts(board.listTasks());
+        }
+        catch {
+            /* a closed db: keep the last counts */
+        }
+        stats.run = { ...(stats.run ?? { phase: "PLAN", done: 0, total: 0, failed: 0 }), ...p, ...counts };
+        // A log (piped, no dock) gets one plain line each time the board's numbers move — never redraws.
+        const r = stats.run;
+        if (!opts.print && !process.stdout.isTTY && board && (r.phase === "BUILD" || r.phase === "QA")) {
+            const key = progressLine(r, null, 200, { on: false });
+            if (key !== logged)
+                print(C.faint(`  ${(logged = key)} · ${fmtDuration(Date.now() - stats.startedAt)}`));
+        }
+    };
+    // You, during the run: agents' questions for you and what you type to them. `huddle join`
+    // on a terminal gets a typing line under the pinned block (KeyLine); the app has its prompt.
+    const oneShotTty = !opts.rl && !opts.print && !!process.stdin.isTTY && !!process.stdout.isTTY;
+    // Every run has one: with no terminal to type in, the dashboard (huddle app) answers and talks.
+    const talk = opts.talk ?? new Talk();
+    let keys = null;
+    let interrupted = 0;
+    let stopNow = null; // set once the build can be stopped cleanly
+    let liveTick = null;
+    let sessionId;
+    let planNow = null;
+    const userNotes = []; // typed before the build starts: delivered when it does
+    // The whole run's off switch: the council, the plan, the build and QA all stop on it.
+    const life = new AbortController();
+    if (opts.signal?.aborted)
+        life.abort();
+    opts.signal?.addEventListener("abort", () => life.abort());
+    /** You asked it to stop (ctrl-c, `stop` in the dashboard): the build stops cleanly and still reports; before the build, everything stops. */
+    const requestStop = () => {
+        if (life.signal.aborted)
+            return;
+        print(C.yellow("  stopping agents…"));
+        if (stopNow)
+            stopNow();
+        else
+            life.abort();
+    };
+    if (talk) {
+        talk.onShow = (q, until) => {
+            stats.ask = { from: q.from, until };
+            print();
+            for (const l of questionLines(q, until))
+                print(l);
+            if (process.stdout.isTTY)
+                process.stdout.write("\x07"); // a bell: you may be in another window
+            act(q.from, `${C.yellow("⚑ asks you:")} ${q.question}`);
+        };
+        talk.onSettled = (q, a) => {
+            const next = talk.current();
+            stats.ask = next ? { from: next.q.from, until: next.until } : undefined;
+            print(settledLine(q, a));
+        };
+        talk.details = () => {
+            if (!planNow)
+                return print(C.faint("  no plan yet — the agents are still designing it"));
+            const d = planDetails(planNow);
+            if (!d.length)
+                return print(C.faint("  this plan has no separate decisions or risks"));
+            for (const l of d)
+                print(l);
+        };
+        talk.say = (line) => {
+            const { to, text } = addressee(line);
+            if (!text)
+                return;
+            if (!board) {
+                userNotes.push(text);
+                return print(`  ${C.violet("✉")} ${C.bold("you")}${C.faint(":")} ${oneLine(text, space("  ✉ you: ", " · noted, every agent gets it when building starts"))} ${C.faint("· noted, every agent gets it when building starts")}`);
+            }
+            const r = sayToAgents(board, text, to);
+            if (to && !r.now.length)
+                return print(C.yellow(`  ! ${to} isn't working on anything right now — say it without @ and every agent that starts next gets it`));
+            const who = r.now.length ? r.now.join(", ") : "every agent that starts next";
+            const head = `  ${C.violet("✉")} ${C.bold("you")} ${C.faint("→")} ${who}${C.faint(":")} `;
+            print(`${head}${oneLine(text, space(head))}`);
+        };
+    }
+    const act = (agent, text) => opts.onActivity?.({ agent, text });
+    /** The run is over: open questions go with option 1, the typing line goes away. */
+    const endTalk = () => {
+        if (liveTick)
+            clearInterval(liveTick);
+        liveTick = null;
+        writeLive(root, snapshot(true));
+        talk?.close();
+        if (talk)
+            talk.say = talk.details = null;
+        stats.ask = undefined;
+        keys?.stop();
+        keys = null;
+    };
+    endTalkNow = endTalk;
+    // The dashboard's view of this run (.huddle/live.json) and what it sends back (.huddle/inbox/): app/live.ts.
+    const councilSoFar = [];
+    const snapshot = (done = false) => {
+        const cur = talk.current();
+        return {
+            pid: process.pid,
+            goal,
+            startedAt: stats.startedAt,
+            updatedAt: Date.now(),
+            ...(sessionId ? { session: sessionId } : {}),
+            ...(planNow?.plain ? { plain: planNow.plain } : {}),
+            narrator: narration(stats),
+            ...(stats.run ? { run: stats.run } : {}),
+            agents: [...stats.agents].map(([id, a]) => ({
+                id,
+                busy: !!a.busySince,
+                ...(a.doing ? { doing: a.doing } : {}),
+                ...(a.pct !== undefined ? { pct: a.pct } : {}),
+                tokens: a.tokens + Math.max(0, a.liveTokens),
+                tasks: a.tasks,
+                reviews: a.reviews,
+            })),
+            council: councilSoFar,
+            ...(cur ? { ask: { id: cur.q.id, from: cur.q.from, question: cur.q.question, options: cur.q.options, ...(cur.q.why ? { why: cur.q.why } : {}), until: cur.until } } : {}),
+            tokens: [...stats.agents.values()].reduce((n, a) => n + a.tokens + Math.max(0, a.liveTokens), 0),
+            ...(budget.limit ? { budget: { limit: budget.limit, used: budget.tokens } } : {}),
+            ...(done ? { done } : {}),
+        };
+    };
+    const command = (c) => {
+        if (c.type === "stop")
+            return requestStop();
+        if (c.type === "say")
+            return talk.say?.(c.text);
+        const cur = talk.current();
+        if (cur && cur.q.id === c.id)
+            talk.answer(c.line);
+    };
+    clearCommands(root);
+    writeLive(root, snapshot());
+    liveTick = setInterval(() => {
+        for (const c of takeCommands(root))
+            command(c);
+        writeLive(root, snapshot());
+    }, 1000);
+    // A one-shot run on a terminal (huddle join): the overall bar and who's on what, pinned under
+    // the output (the prompt app draws the same lines in its footer). Up for the council, then the build.
+    const startDock = () => {
+        if (dock || opts.print || !process.stdout.isTTY)
+            return;
+        if (talk && oneShotTty && !keys)
+            keys = new KeyLine((l) => {
+                if (talk.answer(l))
+                    return;
+                const t = l.trim();
+                if (/^(details|decisions|risks)$/i.test(t))
+                    talk.details?.();
+                else if (t)
+                    talk.say?.(t);
+            }, () => dock?.redraw(), () => {
+                // First ctrl-c: stop the agents and still print what got done. Second: leave now.
+                if (interrupted++) {
+                    endTalk();
+                    stopDock();
+                    // What the terminal does on ctrl-c without raw mode: SIGINT to the whole
+                    // foreground group, agents included. Windows has no process groups.
+                    try {
+                        if (process.platform === "win32")
+                            throw new Error("no process groups");
+                        process.kill(0, "SIGINT");
+                    }
+                    catch {
+                        process.exit(130); // the scheduler's exit hook stops any running agents
+                    }
+                    return;
+                }
+                requestStop();
+                print(C.faint("  (ctrl-c again to quit right away)"));
+            }).start();
+        dock = new Dock(() => [...liveLines(stats, (process.stdout.columns || 80) - 1), ...(keys ? [keys.line()] : [])]).start();
+    };
+    const stopDock = () => {
+        dock?.stop();
+        dock = null;
+    };
     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 repoFiles = git(["ls-files"], root).out.split(/\r?\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) => {
+        phase(print, "COUNCIL", `${members.map((m) => m.id).join(", ")} brainstorm before anyone codes · ${wantCouncil.why} (--no-council skips)`);
+        progress({ phase: "COUNCIL", step: 1 });
+        opts.onStats?.(stats);
+        startDock();
+        /** "  ● codex        adopts claude's: <body, cut to fit> · 14s" */
+        const say = (agent, label, body = "", took = "") => {
+            const head = `  ${dot(agent)} ${pad(agent, 12)} ${label}${body ? " " : ""}`;
+            const text = `${label}${body ? " " + oneLine(body, space(head, took)) : ""}${took}`;
             print(`  ${dot(agent)} ${pad(agent, 12)} ${text}`);
             opts.onActivity?.({ agent, text });
         };
         const onCouncil = (e) => {
+            if (e.type === "ratified")
+                councilSoFar.push({ agent: e.entry.agent, kind: e.entry.verdict === "object" ? "object" : e.entry.verdict === "skipped" ? "skipped" : "ok", text: e.entry.objections.join("\n") });
+            if (e.type === "entry" && e.entry.ok) {
+                const x = e.entry;
+                if (x.round === "proposal")
+                    councilSoFar.push({ agent: x.agent, kind: "proposal", text: x.text.slice(0, 2000) });
+                for (const a of x.adopts ?? [])
+                    councilSoFar.push({ agent: x.agent, kind: "adopt", of: a.of, text: a.text });
+                for (const f of x.flaws ?? [])
+                    councilSoFar.push({ agent: x.agent, kind: "flaw", of: f.of, text: f.text });
+            }
+            const step = e.type === "round" ? (e.round === "proposal" ? 1 : 2) : e.type === "synthesizing" ? 3 : e.type === "ratify" ? 4 : 0;
+            if (step)
+                progress({ phase: "COUNCIL", step });
             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…`));
+                print(C.faint(`  ${e.round === "proposal" ? "1/4 each agent proposes a design…" : "2/4 each agent reviews the others: what to adopt, what's flawed…"}`));
+            if (e.type === "synthesizing") {
+                const head = `  3/4 ${e.brain} writes the plan and its contract`;
+                print(C.faint(`${head}${e.why ? ` · ${oneLine(e.why, space(head, " · "))}` : "…"}`));
+            }
+            if (e.type === "ratify")
+                print(C.faint(`  4/4 ${e.agents.join(", ")} check ${e.by}'s contract…`));
+            if (e.type === "ratified") {
+                const r = e.entry;
+                const took = C.faint(` · ${fmtDuration(r.ms)}`);
+                if (r.verdict === "skipped")
+                    return say(r.agent, C.faint(`ratify skipped (${r.skipped})`), "", took);
+                if (r.verdict === "object")
+                    return say(r.agent, C.yellow(`objects (${r.objections.length}):`), r.objections.join(" · "), took);
+                return say(r.agent, r.verdict === "ok" ? C.green("✓ ok") : C.faint("no clear verdict · taken as ok"), "", took);
+            }
+            if (e.type === "revised")
+                print(e.ok ? `  ${C.green("✓")} ${e.by} revised the plan ${C.faint(`· ${e.taken} objection(s) taken, ${e.rejected} rejected`)}` : C.faint(`  ${e.by} couldn't revise — the plan stands as ratified`));
             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);
+                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)}`);
+                return say(x.agent, C.faint("proposes:"), headline(x.text, "ARCHITECTURE"), took);
+            // A cross-review: what it took from whom, and what it found wrong in whose.
+            const adopt = x.adopts?.[0];
+            const flawPt = x.flaws?.[0];
+            if (!adopt && !flawPt)
+                return say(x.agent, C.faint("flags:"), headline(x.text, "FLAWS"), took);
+            if (adopt)
+                say(x.agent, `${C.green("+ adopts")} ${adopt.of}'s idea:`, adopt.text, took);
+            else
+                say(x.agent, `${C.yellow("! flaw in")} ${flawPt.of}'s idea:`, flawPt.text, took);
+            if (adopt && flawPt) {
+                const head = `  ${" ".repeat(15)}${C.yellow("! flaw in")} ${flawPt.of}'s idea: `;
+                print(`${head}${oneLine(flawPt.text, space(head))}`);
+            }
         };
-        plan = await runCouncil(goal, crew, members, root, { brain, signal: opts.signal, onEvent: onCouncil });
+        // Who synthesized before in this repo's Room: ties rotate the job.
+        let past = {};
+        try {
+            if (opts.room?.db)
+                past = pastSyntheses(opts.room.db);
+            else if (fs.existsSync(dbPath())) {
+                const d = new RoomDB(dbPath());
+                past = pastSyntheses(d);
+                d.close();
+            }
+        }
+        catch {
+            /* no history: roster order */
+        }
+        try {
+            plan = await runCouncil(goal, crew, members, root, { brain, signal: life.signal, onEvent: onCouncil, pastSyntheses: past });
+        }
+        finally {
+            stopDock(); // the plan prints in full; the dock comes back for the build
+        }
     }
     else {
+        progress({ phase: "PLAN" });
+        opts.onStats?.(stats);
         // 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 }));
+        plan = await withSpinner(`planning with ${brain?.label ?? "template"}…`, planGoal(goal, crew, root, { brain, signal: life.signal, project }));
+    }
+    if (life.signal.aborted)
+        return endTalk();
+    planNow = plan;
+    progress({ phase: "PLAN", step: undefined, total: plan.tasks.length });
+    printPlan(print, goal, plan, workers, undefined, !!talk);
+    {
+        let history = runHistory(null);
+        try {
+            if (opts.room?.db)
+                history = runHistory(opts.room.db);
+            else if (fs.existsSync(dbPath())) {
+                const d = new RoomDB(dbPath());
+                history = runHistory(d);
+                d.close();
+            }
+        }
+        catch {
+            /* no history: the defaults */
+        }
+        const qaRounds = shouldQa(goal, { flag: opts.qa, tasks: plan.tasks.length, repoFiles }) ? QA_ROUNDS : 0;
+        print(C.faint(`  ${costPreview({ tasks: plan.tasks.length, agents: workers.length + remoteNow().length, qaRounds, council: plan.council, history, budget })}`));
     }
-    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;
+        return endTalk();
     }
     if (opts.mode === "manual" && rl && !(await yes(rl, `\nStart with ${workers.map((w) => w.id).join(", ")}?`)))
         return;
@@ -551,45 +1004,114 @@ export async function runGoal(goal, opts) {
     const testCmd = detectTestCmd(root);
     const ownRoom = !opts.room;
     const db = opts.room?.db ?? new RoomDB(dbPath());
+    // What this run teaches the next one is learned from its own records (orchestrator/learn.ts).
+    const runStart = Date.now();
+    const seen = [];
     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 } });
+    db.publish("plan.made", { payload: { by: plan.by, note: plan.note ?? null, ms: plan.ms ?? null, tokens: plan.tokens ?? null, tasks: plan.tasks.length, plain: plan.plain ?? null } });
     // 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");
+    // The ratified contract goes on main before any task branches off it, so every worktree has it.
+    if (plan.council?.contract) {
+        const by = plan.council.synthesizer?.id ?? plan.council.synthesizedBy;
+        const ok = commitFile(root, "HUDDLE_CONTRACT.md", contractFile(plan.council.contract, by, plan.council.members), "huddle: the council's contract");
+        const objected = plan.council.objections?.length ?? 0;
+        print(`  ${C.violet("◆")} ${C.faint("contract:")} ${ok ? "HUDDLE_CONTRACT.md on main" : "in the Room (couldn't commit HUDDLE_CONTRACT.md)"} ${C.faint(`· by ${by}` + (objected ? ` · ${plan.council.objections.filter((o) => o.taken).length}/${objected} objection(s) taken` : ""))}`);
+    }
+    const t0 = Date.now();
+    board = db;
+    // What you said while they designed it, and their questions for you from here on.
+    for (const t of userNotes.splice(0))
+        sayToAgents(db, t);
+    sessionId = db.currentSession()?.id;
+    // Someone to ask: a terminal you type in, or the dashboard open on this repo. Nobody: the agent's own pick, at once.
+    room.askUser = (q) => (oneShotTty || opts.rl || openApp(root) ? talk.ask(q) : Promise.resolve({ choice: 1, text: "", by: "default" }));
+    progress({ phase: "BUILD" });
+    opts.onStats?.(stats);
+    phase(print, "BUILD", `${plan.tasks.length} task(s) · ${workers.length + remoteNow().length} agent(s) · each in its own worktree, merged when tests pass`);
+    print(C.faint(`  room ${room.url} · tests: ${testCmd ?? "none yet"} · approvals: ${opts.approvals}`) +
+        (rl ? C.faint(" · ctrl-t live view · ctrl-c stops") : ""));
+    print();
+    startDock();
     const tag = (agent) => `${dot(agent)} ${pad(agent, 12)}`;
-    const act = (agent, text) => opts.onActivity?.({ agent, text });
+    /** "  ● codex        <label> <body, cut to fit><suffix>" */
+    const line = (agent, label, body = "", suffix = "") => {
+        const head = `  ${tag(agent)} ${label}${body ? " " : ""}`;
+        // A quoted title keeps its closing quote when it's cut.
+        const q = /^“([\s\S]*)”$/.exec(body);
+        // On a narrow screen a quoted title gives way entirely before the verdict after it does.
+        if (q && rawSpace(head, suffix) < 14)
+            return `  ${tag(agent)} ${label}${suffix}`;
+        const text = q ? `“${oneLine(q[1], rawSpace(head, suffix) - 2)}”` : body ? oneLine(body, space(head, suffix)) : "";
+        return `${head}${text}${suffix}`;
+    };
+    /** The parts after a title, longest first: the first that leaves the whole title (or 32 cells of it) wins. */
+    const fitting = (agent, label, title, ...suffixes) => suffixes.find((x) => rawSpace(`  ${tag(agent)} ${label} `, x) >= Math.min(32, width(title))) ?? suffixes[suffixes.length - 1];
+    // Handoffs land just before a task starts: one "· read 3 handoffs" on the ▸ line, not a line each.
+    const handoffs = new Map();
+    const sayOne = (agent, label, body = "", suffix = "") => print(line(agent, label, body, suffix));
+    /** Up to `n` lines of a teammate's notes, indented under the line that sent them. */
+    const notesUnder = (notes, n = 3) => {
+        for (const l of notes.split("\n").map((x) => x.replace(/^\s*[-*•]\s*/, "").trim()).filter(Boolean).slice(0, n))
+            print(C.faint(`      ${oneLine(l, space("      "))}`));
+    };
+    let talk_ = 0; // agent-to-agent messages this run, for the teamwork summary
     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)}`);
+            const st = stats.agents.get(agent);
+            if (st)
+                Object.assign(st, { pct: Number(p.pct) || 0, noteAt: Date.now() });
+            sayOne(agent, C.faint(String(p.pct).padStart(3) + "%"), p.note);
             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)}`);
+        else if (e.type === "memory.added" && p.author !== "huddle" && p.author !== USER_ID) {
+            // (Your own words are on screen already, as the ✉ or → line.)
             act(undefined, `${C.violet("◆")} ${C.faint(p.author + " remembered:")} ${oneLine(p.body, 200)}`);
+            // Already on screen as its own line: a task's done note (✓ merged), a QA bug (✗ found), a message (a → b).
+            if (/^Task \S+ done:|^QA \(\S+\) found:|^\S+ → \S+:/.test(String(p.body)))
+                return;
+            const head = `  ${C.violet("◆")} ${pad(String(p.author ?? "memory"), 12)} ${C.faint("noted:")} `;
+            print(`${head}${oneLine(p.body, space(head))}`);
         }
         else if (e.type === "plan.announced" && e.agent_id) {
-            print(`  ${tag(e.agent_id)} ${C.faint("plans:")} ${oneLine(p.intent ?? "", 100)}`);
+            sayOne(e.agent_id, C.faint("plans:"), p.intent ?? "");
             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)}`);
+            // Huddle's own relay of a buddy check is the ◎ buddy check line itself.
+            if (p.from === "huddle" && /^buddy check from/i.test(String(p.body)))
+                return;
+            if (p.from !== "huddle")
+                talk_++;
+            const arrow = `${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${dot(p.to)} ${C.bold(p.to)}${C.faint(":")} `;
+            const kind = p.kind === "answer" ? C.faint("  (answer)") : "";
+            print(`  ${arrow}${oneLine(p.body, space("  ", arrow, kind))}${kind}`);
+            act(undefined, `${arrow}${oneLine(p.body, 200)}`);
         }
     });
-    const t0 = Date.now();
-    const stats = newStats([...workers, ...remoteNow()].map((w) => w.id));
-    opts.onStats?.(stats);
+    // The budget's hard line stops the run as Ctrl-C does: one signal for the board and QA.
+    const stopRun = new AbortController();
+    stopNow = () => stopRun.abort();
+    if (life.signal.aborted)
+        stopRun.abort();
+    life.signal.addEventListener("abort", () => stopRun.abort());
+    budget.add(plan.tokens ?? 0);
+    budget.onLevel((level, b) => {
+        if (level === "soft")
+            print(C.yellow(`  ! budget: ${budgetUse(b)}${b.used < SOFT_AT ? ", about 90% with the work still in flight" : ""} — no new tasks, QA rounds, buddy checks or pairings; running tasks finish`));
+        else {
+            print(C.yellow(`  ! budget: ${budgetUse(b)} — past ${Math.round(HARD_AT * 100)}%, stopping the running agents`));
+            stopRun.abort();
+        }
+    });
+    const unwatchBudget = budget.watch();
     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))
@@ -611,7 +1133,8 @@ export async function runGoal(goal, opts) {
         workers,
         testCmd: (worktree) => detectTestCmd(worktree),
         approvals: opts.approvals,
-        signal: opts.signal,
+        signal: stopRun.signal,
+        budget,
         approveMerge: opts.mode === "manual" && rl
             ? async ({ agent, title, diffstat }) => {
                 print(`\n  ${tag(agent)} ${C.violet("◎ ready")}  ${title}`);
@@ -621,6 +1144,7 @@ export async function runGoal(goal, opts) {
             }
             : undefined,
         onEvent: (e) => {
+            seen.push(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");
@@ -628,11 +1152,9 @@ export async function runGoal(goal, opts) {
                 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 });
+                Object.assign(a, { busySince: Date.now(), liveTokens: -1, doing: e.title, pct: undefined, noteAt: undefined, est: db.getTask(e.task)?.est_seconds ?? undefined }); // -1 = not reported yet
             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,
@@ -641,19 +1163,20 @@ export async function runGoal(goal, opts) {
                     cached: a.cached + e.cached,
                     ms: a.ms + e.ms,
                     tasks: a.tasks + 1,
+                    doing: undefined,
                 });
             if (e.type === "review" && a)
-                Object.assign(a, { busySince: Date.now(), liveTokens: -1 });
+                Object.assign(a, { busySince: Date.now(), liveTokens: -1, doing: `review ${e.author}'s “${e.title}”`, pct: undefined, noteAt: undefined });
             if (e.type === "reviewed" && a)
-                Object.assign(a, { busySince: null, ms: a.ms + e.ms, reviews: a.reviews + 1 });
+                Object.assign(a, { busySince: null, ms: a.ms + e.ms, reviews: a.reviews + 1, doing: undefined });
             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 });
+                    Object.assign(f, { busySince: null, liveTokens: 0, tokens: f.tokens + e.tokens, cached: f.cached + e.cached, ms: f.ms + e.ms, doing: undefined });
                 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))}`);
+                sayOne(e.agent, C.yellow("⤳ " + what), `“${e.title}”`, C.faint(" · " + oneLine(e.reason, 60)));
             }
             if (e.type === "start")
                 act(e.agent, `${C.violet("▸")} ${e.takeover ? `continuing ${e.takeover}'s work: ` : e.fixing ? "fixing after review: " : ""}${e.title}`);
@@ -665,41 +1188,82 @@ export async function runGoal(goal, opts) {
                 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 === "start") {
+                const from = handoffs.get(e.agent) ?? [];
+                handoffs.delete(e.agent);
+                const label = `${C.violet("▸")}${e.takeover ? C.yellow(` continuing ${e.takeover}'s work:`) : e.fixing ? C.yellow(" fixing after review:") : ""}`;
+                const read = from.length ? ` · read ${from.length} handoff${from.length === 1 ? "" : "s"} (${[...new Set(from)].join(", ")})` : "";
+                const remote = e.remote ? ` · offered to ${e.remote}` : "";
+                sayOne(e.agent, label, e.title, C.faint(fitting(e.agent, label, e.title, read + remote, from.length ? ` · read ${from.length} handoff(s)${remote}` : remote, "")));
+            }
+            if (e.type === "contract") {
+                act(e.agent, `${C.violet("◆")} amended the contract (v${e.version}): ${e.section}: ${e.change}`);
+                sayOne(e.agent, `${C.violet("◆ contract v" + e.version)} ${C.faint(e.section + ":")}`, e.change);
+            }
             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}”`)}`);
+                handoffs.set(e.agent, [...(handoffs.get(e.agent) ?? []), e.from]);
             if (e.type === "declined")
-                print(`  ${tag(e.agent)} ${C.faint("✗ declined · back on the board")}  ${C.faint(e.title)}`);
+                sayOne(e.agent, C.faint("✗ declined · back on the board"), e.title);
             if (e.type === "review")
-                print(`  ${tag(e.agent)} ${C.violet("◎")} reviewing ${e.author}'s ${C.faint("“" + e.title + "”")}`);
+                sayOne(e.agent, `${C.violet("◎ reviews")} ${e.author}'s`, `“${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")}`);
+                    sayOne(e.agent, C.faint("○ review skipped ·"), e.notes, C.faint(` · ${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)}`));
+                    notesUnder(e.notes, 4);
                 }
             }
-            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 === "merged") {
+                const short = e.reason.replace(/\s*\([^)]*\)/g, "");
+                const c = cost(e.ms, e.tokens, e.cached);
+                sayOne(e.agent, C.green("✓ merged"), e.title, fitting(e.agent, "✓ merged", e.title, C.faint(" · " + e.reason) + c, C.faint(" · " + short) + c, C.faint(" · " + short.split(" · ")[0]) + c, c));
+            }
             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))}`);
+                sayOne(e.agent, e.needsYou ? C.yellow("! needs you") : C.red("✗ failed"), e.title, C.faint(" · " + oneLine(e.reason, 50)) + 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 });
+                Object.assign(a, { busySince: Date.now(), liveTokens: -1, doing: `fix a merge conflict in “${e.title}”`, pct: undefined, noteAt: undefined });
             if (e.type === "resolved" && a)
-                Object.assign(a, { busySince: null, ms: a.ms + e.ms });
+                Object.assign(a, { busySince: null, ms: a.ms + e.ms, doing: undefined });
             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}`));
+                sayOne(e.agent, C.yellow("⇄ resolving conflict"), `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))}`);
+                sayOne(e.agent, e.ok ? C.green("✓ resolved") : C.yellow("✗ resolution rejected"), "", C.faint(" · " + oneLine(e.reason, 60) + " · " + fmtDuration(e.ms)));
+            // The integration radar told both agents mid-task (their inbox has the details).
+            if (e.type === "radar") {
+                act(e.agent, `${C.yellow("⚠ radar")} ${e.kind === "overlap" ? "overlap" : "name mismatch"} with ${e.with}: ${e.detail}`);
+                sayOne(e.agent, `${C.yellow(e.kind === "overlap" ? "⚠ radar: overlap" : "⚠ radar: name mismatch")} with ${e.with}:`, e.detail);
+            }
+            // A buddy check: another agent read the author's work in progress; notes went to its inbox.
+            if (e.type === "checkpoint") {
+                const ok = /^LOOKS GOOD/i.test(e.notes.trim());
+                act(e.agent, `${C.violet("◎")} buddy check on ${e.author}'s work ${e.pct ? `at ${e.pct}%` : "mid-task"}: ${ok ? "looks good" : oneLine(e.notes, 80)}`);
+                const verdict = ok ? C.green(" · looks good") : e.late ? C.yellow(" · came back after it landed (kept in shared memory)") : C.yellow(" · notes sent");
+                sayOne(e.agent, `${C.violet("◎ buddy check")} ${e.author}'s`, `“${e.title}”`, ` ${e.pct ? `at ${e.pct}%` : "mid-task"}${verdict}`);
+                if (!ok)
+                    notesUnder(e.notes);
+            }
+            // A note that needed an answer, settled: addressed (fixed or replied) or ignored.
+            if (e.type === "followup") {
+                const what = e.kind === "radar" ? "radar finding" : `${e.by}'s buddy note`;
+                const how = e.how === "ignored" ? C.yellow("ignored") : C.green(e.how === "replied" ? "answered" : "addressed in code");
+                sayOne(e.agent, `${C.violet("◎")} ${what} ${how} ${C.faint("·")}`, e.note.replace(/^buddy check from [^:]*:\s*/i, ""), C.faint(` · “${oneLine(e.title, 40)}”`));
+            }
+            if (e.type === "pair") {
+                act(e.agent, `${C.violet("⇉")} pairs with ${e.with}: ${e.part}`);
+                sayOne(e.agent, `${C.violet("⇉ pairs with " + e.with)} on “${oneLine(e.title, 40)}”: takes`, e.part, C.faint(" · " + oneLine(e.reason, 50)));
+            }
+            // Quiet past the silence window, but working (a long test run): not taken over (busy.ts).
+            if (e.type === "busy") {
+                act(e.agent, `${C.faint("⧗ running a long command")} ${C.faint("· " + e.why)}`);
+                sayOne(e.agent, C.faint("⧗ running a long command ·"), `quiet ${fmtDuration(e.quietMs)}, but busy: ${e.why}`);
+            }
+            if (e.type === "start" || e.type === "merged" || e.type === "failed")
+                progress({});
             if (e.type === "stuck")
                 print(C.yellow(`  ! ${e.blocked.length} task(s) blocked by failures: `) + C.faint(e.blocked.join(" · ")));
         },
@@ -708,11 +1272,18 @@ export async function runGoal(goal, opts) {
     // 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 = "";
+    let qaSum = ""; // the RESULT's checks line
+    let qaCut = false; // QA left undone by the budget
     if (!res.stopped && res.merged && shouldQa(goal, { flag: opts.qa, tasks: plan.tasks.length, repoFiles })) {
-        if (res.failed)
+        if (budget.stopping) {
+            qaCut = true;
+            print(C.faint("\n  QA skipped — the token budget is nearly spent"));
+        }
+        else 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")}`);
+            phase(print, "QA", "agents that didn't write it check the build · --no-qa skips");
+            progress({ phase: "QA" });
             const qa = await runQa({
                 db,
                 room,
@@ -722,23 +1293,35 @@ export async function runGoal(goal, opts) {
                 workers,
                 approvals: opts.approvals,
                 testCmd: (wt) => detectTestCmd(wt),
-                signal: opts.signal,
+                signal: stopRun.signal,
+                budget,
                 runFixes: () => runBoard(boardOpts),
                 onEvent: (e) => {
+                    seen.push(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);
+                    if (e.type === "round")
+                        progress({ round: e.round });
+                    else if (e.type === "bug" || e.type === "fixes")
+                        progress({});
                 },
             });
             res.merged += qa.fixed;
             res.failed += qa.failed;
             res.stopped ||= qa.stopped;
+            qaCut = !!qa.budget;
+            qaSum = `${qa.rounds} round(s) · ${qa.bugs} bug(s) found, ${qa.fixed} fixed · ` + (qa.clean ? C.green("last round clean") : C.yellow("last round's fixes not re-checked"));
             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();
+    unwatchBudget();
+    room.askUser = undefined;
+    endTalk();
+    const undone = budget.level === "ok" ? [] : db.listTasks().filter((t) => t.status === "backlog").map((t) => t.title);
     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
@@ -747,15 +1330,58 @@ export async function runGoal(goal, opts) {
         if (ev.task_id && p.kind === "rescue" && p.branch)
             takeovers.set(ev.task_id, String(p.branch));
     }
+    const learned = learnFromRun({ db, root, since: runStart, events: seen });
+    progress({ phase: "DONE" });
+    board = null;
+    // The hand-off brief for whoever works here next, solo (ui/brief.ts).
+    const brief = writeBrief({
+        root,
+        events: db.allEvents(),
+        getHandoff: (id) => db.getHandoff(id),
+        testCmd: detectTestCmd(root),
+        parked: parked.map((t) => ({ title: t.title, branch: takeovers.get(t.id) ?? worktreeFor(root, t.claimed_by ?? "", t.id).branch })),
+        enabled: readPrefs().brief !== false,
+    });
     if (ownRoom) {
         room.close();
         db.close();
     }
     opts.onStats?.(stats);
+    stopDock();
+    // RESULT: what was built and how it was checked, then how the agents worked together, then what it cost.
+    phase(print, "RESULT", "what got built, how it was checked, who did what");
     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)}`)}`);
+    print(`${head} ${res.merged} merged, ${res.failed} failed ${C.faint(`· ${fmtDuration(Date.now() - t0)} · ${tok(total, totalCached)}`)}`);
+    const testsNow = detectTestCmd(root);
+    print(`  ${C.faint(pad("tests", 9))} ${testsNow ? `${C.green("✓")} ${testsNow} passed before every merge` : C.yellow("no test command — merges weren't gated on tests")}`);
+    if (qaSum)
+        print(`  ${C.faint(pad("QA", 9))} ${qaSum}`);
+    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) {
+        const report = await deliver(print, goal, root, startHead, doneNotes, brain, reportFacts(root, startHead, { ...res, testCmd: testsNow, qaNote }));
+        if (sessionId && report.trim())
+            saveReport(root, sessionId, report);
+    }
+    const team = teamworkLines(plan.council, seen, talk_);
+    if (team.length) {
+        print(`\n${C.violet("TEAMWORK")} ${C.faint("· how the agents worked together · huddle story for all of it")}`);
+        for (const t of team) {
+            const label = `  ${C.faint(pad(t.label, 9))} `;
+            print(`${label}${oneLine(t.text, space(label))}`);
+        }
+    }
+    print(`\n${C.violet("COST")} ${C.faint(`· ${fmtDuration(Date.now() - t0)} · ${tok(total, totalCached)}${budget.limit ? ` · ${budgetUse(budget)}` : ""}`)}`);
+    for (const l of budgetNotes(budget, { left: undone, qaCut }))
+        print(C.yellow(`  ! ${l}`));
     for (const [id, a] of stats.agents) {
         if (!a.tasks && !a.reviews && !a.qa) {
             print(`  ${tag(id)} ${C.faint("idle this run")}`);
@@ -768,22 +1394,82 @@ export async function runGoal(goal, opts) {
         ]
             .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`));
+        print(`  ${tag(id)} ${pad(did, 27)} ${pad(fmtDuration(a.ms), 7)} ${a.tasks ? tok(a.tokens, a.cached) : ""}`);
     }
+    if (learned.length)
+        print(C.faint(`  ◆ learned ${learned.length} lesson(s) for next time · huddle lessons to see them`));
+    if (brief)
+        for (const l of briefLines(brief))
+            print(l);
     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 }));
+}
+/**
+ * The run's teamwork, one line each, from what the council and the scheduler
+ * recorded — counts, not judgments. [] for a run where nobody worked with anybody.
+ */
+export function teamworkLines(council, events, messages = 0) {
+    const out = [];
+    const n = (k, one, many = one + "s") => `${k} ${k === 1 ? one : many}`;
+    const of = (t) => events.filter((e) => e.type === t);
+    if (council) {
+        const adopts = council.critiques.flatMap((c) => c.adopts ?? []);
+        const flaws = council.critiques.flatMap((c) => c.flaws ?? []);
+        if (adopts.length || flaws.length) {
+            // "claude's taken by codex, cursor": whose ideas the others built on.
+            const takers = new Map();
+            for (const a of adopts)
+                takers.set(a.of, (takers.get(a.of) ?? new Set()).add(a.by));
+            const whose = [...takers].sort((a, b) => b[1].size - a[1].size).map(([of, by]) => `${of}'s taken by ${[...by].join(", ")}`);
+            out.push({ label: "ideas", text: `${n(adopts.length, "idea")} adopted, ${n(flaws.length, "flaw")} flagged${whose.length ? ` · ${whose.join(" · ")}` : ""}` });
+        }
+        const by = council.synthesizer?.id ?? council.synthesizedBy;
+        const obj = council.objections ?? [];
+        const okd = (council.ratify ?? []).filter((r) => r.verdict === "ok").length;
+        if (council.contract)
+            out.push({
+                label: "contract",
+                text: `written by ${by}${obj.length ? ` · ${obj.filter((o) => o.taken).length} of ${n(obj.length, "objection")} taken` : okd ? ` · ${okd} ratified it as is` : ""}`,
+            });
+    }
+    const amends = of("contract");
+    if (amends.length)
+        out.push({ label: "contract", text: `${n(amends.length, "amendment")} mid-run, now v${Math.max(...amends.map((e) => Number(e.version) || 1))} · ${[...new Set(amends.map((e) => e.agent))].join(", ")}` });
+    const checks = of("checkpoint");
+    if (checks.length) {
+        const sent = checks.filter((e) => !/^LOOKS GOOD/i.test(String(e.notes ?? "").trim()));
+        const ups = of("followup").filter((e) => e.kind !== "radar");
+        const k = (h) => ups.filter((e) => e.how === h).length;
+        out.push({
+            label: "buddy",
+            text: sent.length
+                ? `${n(checks.length, "mid-task check")} · ${n(sent.length, "note")} sent` + (ups.length ? ` → ${k("fixed")} fixed, ${k("replied")} answered, ${k("ignored")} ignored` : "")
+                : `${n(checks.length, "mid-task check")} · all looked good`,
+        });
+    }
+    const radar = of("radar");
+    if (radar.length)
+        out.push({ label: "radar", text: `${n(radar.length, "catch", "catches")} while agents worked: ${radar.slice(0, 3).map((e) => `${e.agent} ↔ ${e.with} (${e.kind})`).join(", ")}` });
+    for (const p of of("pair").slice(0, 3))
+        out.push({ label: "pair", text: `${p.agent} helped ${p.with} on “${p.title}”: ${p.part}` });
+    const takes = of("takeover");
+    if (takes.length)
+        out.push({ label: "takeover", text: takes.slice(0, 3).map((e) => `${e.agent} ${e.kind === "rescue" ? "took over" : "took part of"} ${e.from}'s “${e.title}”`).join(" · ") });
+    const reviews = of("reviewed").filter((e) => !e.skipped);
+    if (reviews.length) {
+        const asked = reviews.filter((e) => !e.approve).length;
+        out.push({ label: "reviews", text: `${n(reviews.length, "cross-review")} · ${reviews.length - asked} approved${asked ? `, ${asked} sent back for changes` : ""}` });
+    }
+    const bugs = events.filter((e) => e.type === "bug" && e.round !== undefined);
+    if (bugs.length) {
+        const fixers = [...new Set(bugs.map((e) => e.assignedTo).filter(Boolean))];
+        out.push({ label: "QA", text: `${n(bugs.length, "bug")} found by ${[...new Set(bugs.map((e) => e.agent))].join(", ")} → fixed by ${fixers.join(", ") || "any free agent"}` });
+    }
+    if (messages)
+        out.push({ label: "talk", text: `${n(messages, "message")} between agents` });
+    return out;
 }
 /** QA's readable lines: "cursor (QA) found: …", "→ fix assigned to codex". */
 function qaLine(e, tag, print, act, stats) {
@@ -792,26 +1478,32 @@ function qaLine(e, tag, print, act, stats) {
         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)") : ""}`);
+            Object.assign(a, { busySince: Date.now(), liveTokens: -1, doing: `QA check, round ${e.round}`, pct: undefined, noteAt: undefined });
+        print(`  ${tag(e.agent)} ${C.violet("◎ QA check:")} runs the tests, uses it, reads the diff${e.author ? C.faint(" · (wrote some of it too)") : ""}`);
         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")}`);
+        const head = `  ${tag(e.agent)} ${C.yellow("✗ QA bug:")} `;
+        // The bug's title first; where it is only if there's room.
+        const full = (e.files.length ? C.faint(" · " + e.files.slice(0, 2).join(", ")) : "") + (e.test ? C.faint(" · + test") : "");
+        const where = space(head, full) >= 40 ? full : "";
+        print(`${head}${oneLine(e.title, space(head, where))}${where}`);
+        print(`  ${pad("", 14)} ${C.faint("→ fix goes 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`)}`);
+        print(`  ${tag(e.agent)} ${C.faint(`= duplicate of “${oneLine(e.of, space("  ", tag(e.agent), " = duplicate of “” · not filed again"))}” · 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 });
+            Object.assign(a, { busySince: null, ms: a.ms + e.ms, tokens: a.tokens + e.tokens, qa: (a.qa ?? 0) + 1, doing: undefined });
         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 === "suspect")
+        print(C.yellow(`  ? QA round ${e.round} clean, but quick`) + C.faint(` · ${e.reason}`));
     if (e.type === "unchecked")
         print(C.yellow(`  ! QA round ${e.round}: the build was NOT checked`) + C.faint(` · ${e.reason}`));
     if (e.type === "capped")
@@ -829,7 +1521,7 @@ function qaLine(e, tag, print, act, stats) {
  * 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 subjects = git(["log", "--format=%s", `${startHead}..HEAD`], root).out.split(/\r?\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).`,
@@ -860,6 +1552,7 @@ You run read-only because Huddle only asks you for this write-up; the run itself
  * 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.
  */
+/** WHAT YOU GOT: the brain's write-up of the run (or the agents' notes). Returns the text, for the dashboard. */
 async function deliver(print, goal, root, startHead, notes, brain, facts = []) {
     const stat = git(["diff", "--stat", `${startHead}..HEAD`], root).out;
     let summary = "";
@@ -869,15 +1562,25 @@ async function deliver(print, goal, root, startHead, notes, brain, facts = []) {
         if (r.ok)
             summary = r.text;
     }
-    print(`\n${C.violet("WHAT YOU GOT")} ${C.faint("· " + shortGoal(goal))}`);
+    print(`\n${C.violet("WHAT YOU GOT")} ${C.faint("· " + shortGoal(goal, space("WHAT YOU GOT · ")))}`);
+    // Wrapped, not cut: this is the part people read. (Command lines keep their indent.)
+    const w = lineWidth();
+    const say = (l) => {
+        if (!w || width(l) <= w - 2)
+            return print("  " + l);
+        const indent = (/^\s*(?:[-*•]\s+|\d+[.)]\s+)?/.exec(l)?.[0] ?? "").replace(/\S/g, " ");
+        for (const part of wrap(l, w - 2, indent))
+            print("  " + part);
+    };
     if (summary)
         for (const l of summary.split("\n"))
-            print("  " + l);
+            say(l);
     else
         for (const n of notes)
-            print("  " + oneLine(n, 160));
+            say(n);
     if (stat)
         print(C.faint("\n  " + stat.split("\n").pop().trim() + C.faint("  ·  see it all: git log")));
+    return summary || notes.join("\n");
 }
 /** Answer a question about the repo, read-only. */
 async function answer(print, question, results, signal) {
@@ -886,7 +1589,7 @@ async function answer(print, question, results, signal) {
     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;
+        brain = asker ? brainFrom(asker.id === "claude" ? "claude:opus" : asker.id) : null;
     }
     if (!brain) {
         print(C.red("  ✗ no agent ready to answer.") + " Type `agents`.");
@@ -909,11 +1612,8 @@ export function printBoard(print = (l = "") => console.log(l)) {
     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}`);
+        print(`  ${statusLabel(t.status)} ${taskMeter(t.progress_pct, 16, t.status)}  ${t.title}  ${who}`);
     }
     const mem = db.recall();
     if (mem.length) {
@@ -962,12 +1662,16 @@ const HELP = `
   ${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.faint("paste")} ${C.faint("/")} ${C.faint("drag a file in")}   long pastes and files go on the shared screen: one copy every agent reads
+  ${C.bold("add")} ${C.faint("<file|dir|glob>")}    put files on the screen  ${C.faint("·")}  ${C.bold("ctx")} ${C.faint("[show|rm|note|clear]")}  what's on it
   ${C.bold("agents")}              reconnect agents; install or sign in to missing ones
+  ${C.bold("agents use|skip")} ${C.faint("<id>")}  pick who works with you: agents skip cursor · agents use cursor
   ${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.")}
+  ${C.faint("While agents work, what you type goes to them (@claude … for one); a question for you shows with numbered options.")}
+  ${C.faint("Questions? end with ? · details: the plan's technical decisions · next <goal>: queue another run.")}
 `;
 // 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"]);
@@ -999,34 +1703,48 @@ export async function runApp() {
     const queue = [];
     let stats = null;
     let ticker = null;
-    /** "⏱ 1m12s · ● claude 40s 31k · ● codex 22s 15k · ○ cursor" */
-    const liveStats = () => {
+    const talk = new Talk(); // agents' questions for you, your lines to them, during a run
+    // Footer under the prompt, like Claude Code's mode line; during a run, the overall bar
+    // ("BUILD ███░░ 6/9 tasks · 12m") and then one line per agent (runLines).
+    const footer = () => {
+        if (!run)
+            return idleFooter();
+        const W = (out.columns || 80) - 1;
+        const chip = `  ${MODE_INFO[state.mode].chip}  `;
+        const queued = queue.length ? C.faint(`  · ${queue.length} queued`) : "";
         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("  ")}`;
+            return [`${chip}${C.violet("● planning…")}${queued}`];
+        const [top] = runLines(stats, W - width(chip) - width(queued) + 2);
+        return [narratorLine(stats, W), `${chip}${top.trimStart()}${queued}`, ...runLines(stats, W).slice(1)];
     };
-    // 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 idleFooter = () => [`  ${MODE_INFO[state.mode].chip} ${C.faint("· " + MODE_INFO[state.mode].desc)}   ` + `${C.faint("approvals:")} ${state.approvals}   ${C.faint("shift+tab to switch")}`];
+    let reserved = 1; // footer lines reserved under the prompt
     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");
+        // Never wrap: a wrapped footer would break the cursor save/restore. Never more lines than were reserved.
+        let ls = footer();
+        if (ls.length > reserved)
+            ls = [...ls.slice(0, reserved - 1), C.faint(`  … ${ls.length - reserved + 1} more · ctrl-t for the live view`)];
+        const w = (out.columns || 80) - 1;
+        out.write("\x1b7" + ls.map((l) => "\x1b[1B\r\x1b[2K" + truncate(l, w)).join("") + "\x1b[J\x1b8");
     };
     const showPrompt = () => {
-        out.write("\n\x1b[1A"); // reserve the footer line below
+        // Reserve the footer lines below the prompt (up to a third of the screen).
+        reserved = Math.max(1, Math.min(footer().length, Math.floor((out.rows || 24) / 3)));
+        out.write("\n".repeat(reserved) + `\x1b[${reserved}A`);
         rl.setPrompt(prompt);
         rl.prompt(true);
         promptShown = true;
         drawFooter();
     };
+    /** The footer grew (a run started, its roster is known): reserve the new lines. */
+    const refitFooter = () => {
+        if (!promptShown || asking || !out.isTTY || footer().length === reserved)
+            return;
+        out.write("\r\x1b[J");
+        showPrompt();
+    };
     // The live view (ctrl-t / `view`). While it's up, prompt output waits.
     const dash = new Dashboard({
         db: () => live?.db ?? null,
@@ -1101,6 +1819,7 @@ export async function runApp() {
         print(C.faint("  (type exit or press ctrl-d to leave)"));
     });
     rl.on("close", () => {
+        bracketedPaste(false);
         out.write("\r\x1b[J");
         console.log(C.faint("bye 👋"));
         process.exit(0); // the scheduler's exit hook stops any running agents
@@ -1159,6 +1878,11 @@ export async function runApp() {
         };
         const unsub = db.onEvent((e) => {
             const p = JSON.parse(e.payload || "{}");
+            const se = screenEvent(e); // notes, reads and teammates' items on the shared screen
+            if (se?.print)
+                print(se.print);
+            if (se?.dash)
+                dash.push(se.dash);
             if (e.type === "member.joined")
                 print(`  ${C.green("●")} ${C.bold(p.name)} joined the room ${C.faint("· " + p.role)}`);
             if (e.type === "member.left")
@@ -1219,7 +1943,7 @@ export async function runApp() {
                         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]}`));
+                        print(add.status === 0 ? `  ${C.green("✓")} GitHub invite sent to @${handle}` : C.red(`  ✗ ${add.stderr.trim().split(/\r?\n/)[0]}`));
                     }
                 }
                 else if (collab)
@@ -1339,9 +2063,58 @@ export async function runApp() {
         promptShown = false;
         out.write("\r\x1b[J");
         rl.pause();
-        spawnSync("sh", ["-c", cmd], { stdio: "inherit" });
+        bracketedPaste(false);
+        runShell(cmd);
+        bracketedPaste(true);
         rl.resume();
     };
+    // ---- the shared screen: pastes, dropped files, `add`, `ctx` (src/ui/paste.ts) ----
+    const screenUI = {
+        print,
+        // A question mid-line would swallow what's typed: park it, ask, put it back.
+        yes: async (q, def) => {
+            const keep = rl.line;
+            if (keep)
+                rl.write(null, { ctrl: true, name: "u" });
+            try {
+                return await yes(rl, q, def);
+            }
+            finally {
+                if (keep)
+                    rl.write(keep);
+            }
+        },
+        db: async () => (await openRoom())?.db ?? null,
+        audience: () => {
+            const ready = results.filter((r) => r.state === "ready");
+            return { agents: ready.map((r) => r.adapter.id), companies: new Set(ready.map((r) => r.adapter.vendor)).size };
+        },
+        brain: () => resolveBrain(results),
+        root: repoRoot,
+        interactive: true,
+    };
+    if (out.isTTY && process.stdin.isTTY) {
+        bracketedPaste(true);
+        process.once("exit", () => bracketedPaste(false));
+        interceptStdin(process.stdin, (pass) => new PasteCatcher({
+            pass,
+            enabled: () => !asking && !dash.isOpen(),
+            onPaste: (text) => {
+                const drop = asDrop(text);
+                // Short pastes stay on the line, as one line.
+                if (!drop && !isLongPaste(text))
+                    return pass(flatten(text));
+                void (async () => {
+                    if (drop)
+                        await addPaths(drop, screenUI);
+                    else
+                        await pasteToScreen(text, screenUI);
+                    if (!promptShown)
+                        showPrompt();
+                })().catch((e) => print(C.red("  error: ") + (e?.message ?? e)));
+            },
+        }));
+    }
     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;
@@ -1359,10 +2132,14 @@ export async function runApp() {
                 rl,
                 signal: run.signal,
                 print,
-                onStats: (s) => (stats = s),
+                onStats: (s) => {
+                    stats = s;
+                    refitFooter();
+                },
                 room: r ?? undefined,
                 onActivity: (a) => dash.push(a),
                 qa,
+                talk,
             });
         }
         catch (e) {
@@ -1389,6 +2166,11 @@ export async function runApp() {
         const line = raw.trim();
         promptShown = false;
         out.write("\x1b[2K"); // clear the footer line we just moved onto
+        // An agent asked you something: this line is the answer (Enter = the recommended option).
+        if (run && talk.current() && !/^(stop|exit|quit|view|help|\?|details)$/i.test(line)) {
+            talk.answer(line);
+            return showPrompt();
+        }
         if (!line)
             return showPrompt();
         const [cmd, ...rest] = line.split(/\s+/);
@@ -1397,7 +2179,14 @@ export async function runApp() {
         try {
             if (cmd === "exit" || cmd === "quit")
                 return rl.close();
-            if (cmd === "help" || cmd === "?")
+            const drop = asDrop(line); // a file dragged in by a terminal that doesn't mark pastes
+            if (drop)
+                await addPaths(drop, screenUI);
+            else if (cmd === "add" && looksLikePaths(line.slice(3)))
+                await addPaths(splitPathTokens(line.slice(3)), screenUI);
+            else if (cmd === "ctx" || cmd === "context" || cmd === "screen")
+                await ctxCommand(line.slice(cmd.length), screenUI);
+            else if (cmd === "help" || cmd === "?")
                 print(HELP);
             else if (cmd === "clear" || cmd === "cls") {
                 out.write("\x1b[2J\x1b[3J\x1b[H");
@@ -1467,8 +2256,14 @@ export async function runApp() {
                     print(C.faint("  nothing running"));
             }
             else if (cmd === "agents") {
+                const [verb, ...ids] = arg.split(/[\s,]+/).filter(Boolean);
                 if (run)
                     print(C.faint("  finish or stop the current run first"));
+                else if ((verb === "use" || verb === "skip") && ids.length) {
+                    setAgentChoice(ids, verb === "use");
+                    print(C.faint(`  ${verb === "use" ? "using" : "skipping"} ${ids.join(", ")} from now on`));
+                    results = await connectAgents();
+                }
                 else {
                     results = await connectAgents();
                     if (await offerSetup(rl, results, true))
@@ -1504,11 +2299,20 @@ export async function runApp() {
                 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))) {
+            else if (cmd === "details" && run)
+                talk.details?.();
+            else if (cmd === "ask" || (cmd !== "build" && cmd !== "join" && cmd !== "next" && isQuestion(line))) {
                 await answer(print, cmd === "ask" ? arg : line, results);
             }
+            else if (run && cmd !== "build" && cmd !== "join" && cmd !== "next") {
+                // During a run, what you type goes to the agents (room/user.ts). A new goal waits: "next <goal>".
+                if (talk.say)
+                    talk.say(line);
+                else
+                    print(C.faint("  the agents are wrapping up — say it again in a moment, or `next <goal>` for a new run"));
+            }
             else {
-                const goal = cmd === "build" || cmd === "join" ? arg : line;
+                const goal = cmd === "build" || cmd === "join" || cmd === "next" ? arg : line;
                 if (!goal)
                     print(C.faint("  usage: build <goal>"));
                 else if (run) {