huddle-cli 0.1.0 → 0.1.1

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,21 @@ 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 { 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 { learnFromRun } from "../orchestrator/learn.js";
+import { PasteCatcher, addPaths, asDrop, bracketedPaste, ctxCommand, flatten, interceptStdin, isLongPaste, looksLikePaths, pasteToScreen, screenEvent } from "./paste.js";
+import { splitPathTokens } from "../room/context.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 +85,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 +100,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));
+    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 +195,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 +235,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 +289,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 +309,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 +319,29 @@ 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
+ *   ○ cursor   idle · 2 done
+ * Every line fits `W` cells: 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 pct = a.pct === undefined ? C.faint("  · ") : C.violet(`${String(a.pct).padStart(3)}%`);
+        const quiet = a.noteAt === undefined ? now - a.busySince : now - a.noteAt;
+        const said = a.noteAt === undefined ? "no note yet" : `note ${fmtDuration(now - a.noteAt)} ago`;
+        const tail = (quiet > 120_000 ? C.yellow(` · ${said}`) : C.faint(` · ${said}`)) +
+            C.faint(` · ${fmtDuration(now - a.busySince)}${a.liveTokens > 0 ? ` · ${fmtTokens(a.liveTokens)} tok` : ""}`);
+        const room = Math.max(8, W - width(head) - 5 - width(tail));
+        return `${head}${pct} ${pad(truncate(a.doing ?? "working", room), Math.min(room, 34))}${tail}`;
+    });
+}
 export function newStats(workers) {
     return {
         startedAt: Date.now(),
@@ -340,7 +423,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 +441,7 @@ 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/"));
+    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 +506,41 @@ export function likelyAgents(tasks, workers) {
     }
     return out;
 }
+/** 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}`);
+}
 function printPlan(print, goal, plan, workers) {
     const took = plan.ms ? ` in ${fmtDuration(plan.ms)}` : "";
-    print(`\n${C.violet("PLAN")} ${C.faint("· " + shortGoal(goal) + " · by " + plan.by + took + (plan.note ? " — " + plan.note : ""))}`);
+    phase(print, "PLAN", `${plan.tasks.length} task(s) · by ${plan.by}${took}${plan.note ? " — " + plan.note : ""}`);
+    print(`  ${C.faint("goal:")} ${oneLine(goal, space("  goal: "))}`);
     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}`);
+        const who = fit ? `  ${C.faint("→ likely")} ${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.
     for (const d of plan.council?.decisions ?? [])
-        print(`  ${C.violet("◆")} ${C.faint("decided:")} ${oneLine(d, 110)}`);
-    for (const r of plan.council?.risks ?? [])
-        print(`  ${C.yellow("!")} ${C.faint("risk" + (r.by ? ` (${r.by})` : "") + ":")} ${oneLine(r.body, 105)}`);
+        print(`  ${C.violet("◆")} ${C.faint("decided:")} ${oneLine(d, space("  ◆ decided: "))}`);
+    for (const r of plan.council?.risks ?? []) {
+        const label = `  ${C.yellow("!")} ${C.faint("risk" + (r.by ? ` (${r.by})` : "") + ":")} `;
+        print(`${label}${oneLine(r.body, space(label))}`);
+    }
 }
 /** Show a spinner line while a promise settles (TTY only). */
 async function withSpinner(label, p) {
@@ -456,7 +557,11 @@ async function withSpinner(label, p) {
     }
 }
 export async function runGoal(goal, opts) {
-    const print = opts.print ?? ((l = "") => console.log(l));
+    // 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)
@@ -485,37 +590,77 @@ export async function runGoal(goal, opts) {
     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)`);
+        /** "  ● 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 === "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 */
+        }
+        plan = await runCouncil(goal, crew, members, root, { brain, signal: opts.signal, onEvent: onCouncil, pastSyntheses: past });
     }
     else {
         // A big goal without a council (--no-council, or one agent) still gets a project-sized plan.
@@ -551,6 +696,9 @@ 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);
@@ -559,37 +707,86 @@ export async function runGoal(goal, opts) {
     // 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();
+    const stats = newStats([...workers, ...remoteNow()].map((w) => w.id));
+    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();
+    // A one-shot run on a terminal (huddle join): who's on what, pinned under the output.
+    // (The prompt app draws the same lines in its footer.)
+    if (!opts.print && process.stdout.isTTY)
+        dock = new Dock(() => [
+            C.faint(`  ⏱ ${fmtDuration(Date.now() - t0)} · ${[...stats.agents.values()].reduce((n, a) => n + a.tasks, 0)} merged so far`),
+            ...statusLines(stats, (process.stdout.columns || 80) - 1),
+        ]).start();
     const tag = (agent) => `${dot(agent)} ${pad(agent, 12)}`;
+    /** "  ● 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 act = (agent, text) => opts.onActivity?.({ agent, text });
     const unsub = db.onEvent((e) => {
         const p = JSON.parse(e.payload || "{}");
         if (e.type === "task.progress" && p.note) {
             const agent = (e.task_id ? db.getTask(e.task_id)?.claimed_by : "") ?? "";
-            print(`  ${tag(agent)} ${C.faint(String(p.pct).padStart(3) + "%")}  ${oneLine(p.note, 100)}`);
+            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)}`);
             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);
     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))
@@ -621,6 +818,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 +826,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 }); // -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 +837,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 +862,75 @@ 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)));
+            }
             if (e.type === "stuck")
                 print(C.yellow(`  ! ${e.blocked.length} task(s) blocked by failures: `) + C.faint(e.blocked.join(" · ")));
         },
@@ -708,11 +939,12 @@ 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
     if (!res.stopped && res.merged && shouldQa(goal, { flag: opts.qa, tasks: plan.tasks.length, repoFiles })) {
         if (res.failed)
             print(C.faint(`\n  QA skipped — ${res.failed} task(s) didn't merge; it checks finished builds only`));
         else {
-            print(`\n${C.violet("QA")} ${C.faint("· agents that didn't write it check the build · --no-qa to skip")}`);
+            phase(print, "QA", "agents that didn't write it check the build · --no-qa skips");
             const qa = await runQa({
                 db,
                 room,
@@ -725,6 +957,7 @@ export async function runGoal(goal, opts) {
                 signal: opts.signal,
                 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);
@@ -733,6 +966,7 @@ export async function runGoal(goal, opts) {
             res.merged += qa.fixed;
             res.failed += qa.failed;
             res.stopped ||= qa.stopped;
+            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.`;
@@ -747,15 +981,43 @@ 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 });
     if (ownRoom) {
         room.close();
         db.close();
     }
     opts.onStats?.(stats);
+    dock?.stop();
+    dock = null;
+    // 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)
+        await deliver(print, goal, root, startHead, doneNotes, brain, reportFacts(root, startHead, { ...res, testCmd: testsNow, qaNote }));
+    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)}`)}`);
     for (const [id, a] of stats.agents) {
         if (!a.tasks && !a.reviews && !a.qa) {
             print(`  ${tag(id)} ${C.faint("idle this run")}`);
@@ -768,22 +1030,79 @@ 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 (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 +1111,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 +1154,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).`,
@@ -869,13 +1194,22 @@ 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")));
 }
@@ -886,7 +1220,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`.");
@@ -962,7 +1296,10 @@ 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)")}
@@ -999,34 +1336,47 @@ export async function runApp() {
     const queue = [];
     let stats = null;
     let ticker = null;
-    /** "⏱ 1m12s · ● claude 40s 31k · ● codex 22s 15k · ○ cursor" */
+    /** "⏱ 1m12s · 3 merged so far" — the per-agent lines (statusLines) go under it. */
     const liveStats = () => {
         if (!stats)
             return C.violet("● planning…");
-        const now = Date.now();
-        const parts = [...stats.agents].map(([id, a]) => a.busySince
-            ? `${dot(id)} ${id} ${fmtDuration(now - a.busySince)} ${C.faint(a.liveTokens < 0 ? "…" : fmtTokens(a.liveTokens) + " tok")}`
-            : C.faint(`○ ${id}`));
-        return `${C.faint("⏱")} ${fmtDuration(now - stats.startedAt)}  ${parts.join("  ")}`;
+        const merged = [...stats.agents.values()].reduce((n, a) => n + a.tasks, 0);
+        return `${C.faint("⏱")} ${fmtDuration(Date.now() - stats.startedAt)} ${C.faint(`· ${merged} merged so far`)}`;
     };
-    // Footer under the prompt, like Claude Code's mode line.
+    // Footer under the prompt, like Claude Code's mode line; during a run, one more line per agent.
     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")}`;
+        ? [
+            `  ${MODE_INFO[state.mode].chip}  ${liveStats()}${queue.length ? C.faint(`  · ${queue.length} queued`) : ""}`,
+            ...(stats ? statusLines(stats, (out.columns || 80) - 1) : []),
+        ]
+        : [`  ${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 +1451,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 +1510,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 +1575,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 +1695,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,7 +1764,10 @@ 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,
@@ -1397,7 +1805,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 +1882,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))