huddle-cli 0.1.0 → 0.1.1

package/dist/ui/catalog.js

@@ -1,34 +1,45 @@
 // `huddle agents --all`: every connector Huddle knows — built in, or declared
 // in agents.json — with whether it's on this machine and how to get it.
 // `huddle agents install <id>` installs one, always after asking.
+import os from "node:os";
 import readline from "node:readline/promises";
-import { spawnSync } from "node:child_process";
-import { ADAPTERS, AGENTS_FILE_ERRORS, BUILTIN_ADAPTERS, probe } from "../adapters/index.js";
+import { ADAPTERS, AGENTS_FILE_ERRORS, BUILTIN_ADAPTERS, LEGACY, installCommand, noInstallHint, probe } from "../adapters/index.js";
 import { agentsFiles } from "../adapters/custom.js";
-import { C, dot, pad } from "./term.js";
+import { runInteractive, setAgentChoice, skippedAgents } from "./app.js";
+import { C, dot, lineWidth, pad, wrap } from "./term.js";
 function all() {
     const seen = new Map();
     for (const a of [...BUILTIN_ADAPTERS, ...ADAPTERS])
         seen.set(a.id, a); // the roster's version wins (agents.json overrides)
     return [...seen.values()];
 }
-const tilde = (p) => p.replace(process.env.HOME ?? "\0", "~");
+const tilde = (p) => p.replace(os.homedir(), "~");
+const stateText = (r) => r.state === "ready" ? C.green("ready") : r.state === "not_authed" ? C.yellow("not signed in") : C.faint("not installed");
+/** One agent's row: state, whether you use it, and the next command when there is one. */
+function printRow(a, r, skipped) {
+    const from = a.source ? C.faint(` · ${tilde(a.source)}`) : "";
+    const choice = skipped ? C.faint("skipped") : C.violet("used");
+    console.log(`  ${dot(a.id)} ${pad(C.bold(a.id), 13)} ${pad(C.faint(a.vendor), 13)} ${pad(stateText(r), 14)} ${from ? pad(choice, 8) + from : choice}`);
+    if (skipped)
+        return;
+    const cmd = installCommand(a);
+    // Hints wrap under the row (80 columns when piped), never past the edge.
+    const hint = (t) => wrap(t, (lineWidth() ?? 80) - 7, "  ").forEach((l) => console.log(`      ${C.faint(l)}`));
+    if (r.state === "not_installed")
+        hint(cmd ? "$ " + cmd : noInstallHint(a));
+    else if (r.state === "not_authed")
+        hint(r.detail);
+}
 export function printCatalog() {
     console.log(`\n${C.bold("Connectors")} ${C.faint("· any CLI that runs headless and speaks MCP can join")}\n`);
-    for (const a of all()) {
-        const r = probe(a);
-        const state = r.state === "ready" ? C.green("ready") : r.state === "not_authed" ? C.yellow("not signed in") : C.faint("not installed");
-        const from = a.source ? C.faint(` · ${tilde(a.source)}`) : "";
-        console.log(`  ${dot(a.id)} ${pad(C.bold(a.id), 13)} ${pad(C.faint(a.vendor), 13)} ${pad(state, 14)}${from}`);
-        if (r.state === "not_installed" && a.install.cmd)
-            console.log(`      ${C.faint("$ " + a.install.cmd)}`);
-        else if (r.state === "not_authed")
-            console.log(`      ${C.faint(r.detail)}`);
-    }
+    const skip = skippedAgents();
+    for (const a of all())
+        printRow(a, probe(a), skip.has(a.id));
     for (const e of AGENTS_FILE_ERRORS)
         console.log(`  ${C.yellow("!")} ${C.faint(e)}`);
     const f = agentsFiles(null);
     console.log(`\n  ${C.faint("install one:")} huddle agents install <id>`);
+    console.log(`  ${C.faint("choose:")}      huddle agents use <id>  ${C.faint("·")}  huddle agents skip <id>`);
     console.log(`  ${C.faint("add your own:")} ${tilde(f.user)} ${C.faint("(see docs/ADAPTERS.md)")}\n`);
 }
 /** Install a connector's CLI (and offer its sign-in) — only after a yes. */
@@ -38,32 +49,29 @@ export async function installConnector(id) {
         console.log(C.red(`✗ no connector called ${id}.`) + " See `huddle agents --all`.");
         return false;
     }
-    if (!a.install.cmd) {
-        console.log(`${a.id} has no install command — install ${a.bin} the way its docs say${a.homepage ? `: ${a.homepage}` : "."}`);
+    const cmd = installCommand(a);
+    if (!cmd) {
+        console.log(`${a.id}: ${noInstallHint(a)}`);
         return false;
     }
     if (!process.stdin.isTTY) {
-        console.log(`To install ${a.id}, run:\n  ${a.install.cmd}`);
+        console.log(`To install ${a.id}, run:\n  ${cmd}`);
         return false;
     }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
-        console.log(`\n  ${dot(a.id)} ${C.bold(a.id)}  ${C.faint("$ " + a.install.cmd)}`);
+        console.log(`\n  ${dot(a.id)} ${C.bold(a.id)}  ${C.faint("$ " + cmd)}`);
         const ans = (await rl.question(`Install ${a.id}? ${C.faint("[Y/n]")} `)).trim().toLowerCase();
         if (ans && !ans.startsWith("y"))
             return false;
-        rl.pause();
-        const ok = spawnSync("sh", ["-c", a.install.cmd], { stdio: "inherit" }).status === 0;
-        rl.resume();
+        const ok = runInteractive(rl, cmd);
         console.log(ok ? C.green(`✓ ${a.id} installed`) : C.red(`✗ ${a.id} install failed — see output above`));
         if (ok && a.install.login) {
             const go = (await rl.question(`Sign in to ${a.id} now? ${C.faint("[Y/n]")} `)).trim().toLowerCase();
             if (!go || go.startsWith("y")) {
                 if (a.install.loginNote)
                     console.log(C.faint(`  ${a.install.loginNote}`));
-                rl.pause();
-                spawnSync(a.install.login[0], a.install.login.slice(1), { stdio: "inherit" });
-                rl.resume();
+                runInteractive(rl, a.install.login);
             }
         }
         return ok;
@@ -72,4 +80,34 @@ export async function installConnector(id) {
         rl.close();
     }
 }
+/** `huddle agents`: the agents Huddle would use here, their state, and your use/skip choice. */
+export function printAgents() {
+    const skip = skippedAgents();
+    console.log(`\n${C.bold("Your agents")}\n`);
+    for (const a of ADAPTERS) {
+        const r = probe(a);
+        // Opt-in connectors stay out of the list until their CLI is on this machine.
+        if (LEGACY.has(a.id) && r.state === "not_installed")
+            continue;
+        printRow(a, r, skip.has(a.id));
+    }
+    console.log(`\n  ${C.faint("choose:")}          huddle agents use claude,codex  ${C.faint("·")}  huddle agents skip cursor`);
+    console.log(`  ${C.faint("set up the rest:")} huddle setup`);
+    console.log(`  ${C.faint("every connector:")} huddle agents --all\n`);
+}
+/** `huddle agents use|skip <ids>`: remembered in ~/.huddle/prefs.json. */
+export function chooseAgents(verb, list) {
+    const ids = list.flatMap((x) => x.split(",")).map((s) => s.trim()).filter(Boolean);
+    const known = new Set(all().map((a) => a.id));
+    const unknown = ids.filter((id) => !known.has(id));
+    if (!ids.length || unknown.length) {
+        console.log(C.red(`✗ no agent called ${unknown.join(", ") || "(none given)"}.`) + ` Known: ${[...known].join(", ")}`);
+        return false;
+    }
+    setAgentChoice(ids, verb === "use");
+    console.log(verb === "use"
+        ? `${C.green("✓")} using ${ids.join(", ")} ${C.faint("— `huddle setup` installs or signs in any that aren't ready")}`
+        : `${C.green("✓")} skipping ${ids.join(", ")} ${C.faint("— never installed, asked about, or put to work. Undo: huddle agents use " + ids.join(","))}`);
+    return true;
+}
 //# sourceMappingURL=catalog.js.map

package/dist/ui/dashboard.js

@@ -1,18 +1,61 @@
 // The live view — the full-screen dashboard from the launch film.
 //
-//   ⬢ huddle   1 agents  2 plan  3 board        room: <goal>  ● live  ⏱ 1m12s
-//   ┌ ● claude  anthropic ─ working 40s · 31k ┐┌ ● codex  openai ─ idle ───────┐
-//   │ ▸ Add greet(name) with tests            ││ ✓ merged Add farewell…         │
-//   │   plans: CommonJS greet.js …            ││                                │
-//   └─────────────────────────────────────────┘└────────────────────────────────┘
-//   ◆ harsh/codex → room  what shape is the Order type?
+//   ⬢ huddle  1 agents  2 plan  3 board       BUILD · ● live · ⏱ 1m12s
+//   ╭─ ● claude  working 40s · 31k tok ──────╮╭─ ● codex  idle · 1 merged ───╮
+//   │ ▸ Add greet(name) with tests   60%     ││ ✓ merged Add farewell…        │
+//   │   plans: CommonJS greet.js …           ││                               │
+//   ╰────────────────────────────────────────╯╰───────────────────────────────╯
+//   ◆ codex → claude: what shape is the Order type?
 //   1 2 3 switch · q back to the prompt · ctrl-c stop agents
 //
 // It only reads: the Room's board and memory, the run's live stats, and the
-// activity feed. Pressing q hands the terminal back to the prompt.
+// activity feed. Pressing q hands the terminal back to the prompt. Every row
+// is cut to the screen's width — a row that wraps scrolls the whole frame.
 import { C, dot, pad, truncate, width, AGENT_COLOR } from "./term.js";
 import { fmtDuration, fmtTokens } from "../adapters/usage.js";
+import { taskViews } from "../room/progress.js";
+import { getContract } from "../room/contract.js";
+import { screenPanel } from "../room/context.js";
+const PHASE_OF = {
+    "council.proposal": "COUNCIL",
+    "council.critique": "COUNCIL",
+    "council.adopt": "COUNCIL",
+    "council.flaw": "COUNCIL",
+    "council.ratify": "COUNCIL",
+    "council.plan": "PLAN",
+    "plan.made": "PLAN",
+    "contract.set": "PLAN",
+    "run.start": "BUILD",
+    "qa.round": "QA",
+};
+/**
+ * The run's phase: the latest phase-marking event since the session began,
+ * and DONE once every task on the board is merged or failed and no agent is busy.
+ */
+export function runPhase(db, busy) {
+    if (!db)
+        return "WAITING";
+    let tasks = [];
+    let since = 0;
+    try {
+        tasks = db.listTasks();
+        since = (db.currentSession()?.created_at ?? 1) - 1;
+    }
+    catch {
+        return "WAITING"; // a closed db
+    }
+    const last = db.eventsOfType(Object.keys(PHASE_OF), since, 1).at(-1);
+    let phase = last ? PHASE_OF[last.type] : "WAITING";
+    // A QA round's fix tasks are BUILD work, but the run is still in QA.
+    if (phase !== "QA" && phase !== "WAITING" && db.eventsOfType(["qa.round"], since, 1).length)
+        phase = "QA";
+    if (!busy && tasks.length && tasks.every((t) => t.status === "merged" || t.status === "failed"))
+        return "DONE";
+    return phase;
+}
 const hexColor = (id) => C.hex(AGENT_COLOR[id.split("/").pop().split("#")[0]] ?? "#8A857C");
+/** The shared screen's 📎/📌 rows in the view's glyphs (emoji are two cells wide and vary by font). */
+const screenGlyphs = (l) => l.replace(/^📎/u, C.violet("+")).replace(/^📌/u, C.violet("◆"));
 export class Dashboard {
     src;
     tab = "agents";
@@ -82,105 +125,205 @@ export class Dashboard {
     render() {
         if (!this.open)
             return;
-        const W = process.stdout.columns || 100;
-        const H = process.stdout.rows || 30;
+        const lines = this.frame(process.stdout.columns || 100, process.stdout.rows || 30);
+        process.stdout.write("\x1b[H" + lines.map((l) => "\x1b[2K" + l).join("\n"));
+    }
+    /** One full screen, `H` rows each at most `W` cells (also how tests and samples render it). */
+    frame(W, H, tab = this.tab, now = Date.now()) {
         const db = this.src.db();
         const stats = this.src.stats();
-        const goal = db?.currentSession()?.goal ?? "no goal yet — press q and type one";
+        const busy = !!stats && [...stats.agents.values()].some((a) => a.busySince);
+        const phase = runPhase(db, busy);
+        let goal = "";
+        try {
+            goal = db?.currentSession()?.goal ?? "";
+        }
+        catch {
+            /* a closed db */
+        }
         const tabs = ["agents", "plan", "board"]
-            .map((t, i) => (t === this.tab ? C.bold(C.violet(` ${i + 1} ${t} `)) : C.faint(` ${i + 1} ${t} `)))
+            .map((t, i) => (t === tab ? C.bold(C.violet(`[${i + 1} ${t}]`)) : C.faint(` ${i + 1} ${t} `)))
             .join(" ");
-        const right = `${C.faint("room:")} ${truncate(goal, Math.max(10, W - 70))}  ` +
-            (stats ? `${C.green("● live")}  ${C.faint("⏱")} ${fmtDuration(Date.now() - stats.startedAt)}` : C.faint("○ idle"));
+        const clock = stats ? `${C.faint("⏱")} ${fmtDuration((stats.endedAt ?? now) - stats.startedAt)}` : "";
+        const state = phase === "DONE"
+            ? C.green("✓ done")
+            : phase === "WAITING"
+                ? C.faint("○ waiting for a run")
+                : `${C.bold(C.violet(phase))} ${C.faint("·")} ${busy ? C.green("● live") : C.faint("○ between steps")}`;
+        const right = [state, clock].filter(Boolean).join(C.faint(" · "));
         const bar = ` ${C.violet("⬢")} ${C.bold("huddle")}  ${tabs}`;
-        const top = bar + " ".repeat(Math.max(1, W - width(bar) - width(right) - 1)) + right;
+        // The goal takes whatever room is left between the tabs and the status.
+        const room = W - width(bar) - width(right) - 4;
+        const goalS = goal && room >= 12 ? C.faint(truncate(goal.replace(/\s+/g, " "), room)) : "";
+        const gap = Math.max(1, W - width(bar) - width(goalS) - width(right) - 3);
+        const top = goalS ? `${bar}  ${goalS}${" ".repeat(gap)}${right}` : `${bar}${" ".repeat(Math.max(1, W - width(bar) - width(right) - 1))}${right}`;
         const bodyH = H - 4;
-        const body = this.tab === "agents" ? this.agents(W, bodyH, stats) : this.tab === "plan" ? this.plan(W, bodyH, db) : this.board(W, bodyH, db);
+        const body = tab === "agents" ? this.agents(W, bodyH, stats, db, now) : tab === "plan" ? this.plan(W, bodyH, db) : this.board(W, bodyH, db);
         const lastRoom = [...this.feed].reverse().find((a) => !a.agent);
-        const strip = lastRoom ? ` ${truncate(lastRoom.text, W - 2)}` : C.faint(" the room is quiet");
-        const hint = C.faint(` ${this.src.hint ?? "1 2 3 switch · q back to the prompt · ctrl-c stop agents"}   ${this.src.modeChip()}`);
-        const lines = [truncate(top, W), C.faint("─".repeat(W)), ...body.slice(0, bodyH), strip, hint];
-        while (lines.length < H)
-            lines.splice(lines.length - 2, 0, "");
-        process.stdout.write("\x1b[H" + lines.slice(0, H).map((l) => "\x1b[2K" + truncate(l, W)).join("\n"));
+        const strip = lastRoom ? ` ${lastRoom.text}` : C.faint(" the room is quiet");
+        const hint = C.faint(` ${this.src.hint ?? "1 2 3 switch · q back to the prompt · ctrl-c stop agents"}   `) + this.src.modeChip();
+        const lines = [top, C.faint("─".repeat(W)), ...body.slice(0, bodyH)];
+        while (lines.length < H - 2)
+            lines.push("");
+        lines.push(strip, hint);
+        return lines.slice(0, H).map((l) => truncate(l.replace(/[\r\n]+/g, " "), W));
     }
     /** Tab 1: a pane per agent — what each one is doing right now. */
-    agents(W, H, stats) {
+    agents(W, H, stats, db, now) {
         const ids = stats ? [...stats.agents.keys()] : [...new Set(this.feed.filter((a) => a.agent).map((a) => a.agent))];
         if (!ids.length)
-            return [C.faint("  no agents working — give Huddle a goal")];
+            return ["", C.faint(`  ${this.src.empty ?? "no agents working — give Huddle a goal"}`)];
+        let views = [];
+        try {
+            views = db ? taskViews(db, now) : [];
+        }
+        catch {
+            /* a closed db: no pinned task line */
+        }
         const cols = W >= 110 && ids.length > 1 ? 2 : 1;
         const rows = Math.ceil(ids.length / cols);
         const paneW = Math.floor(W / cols);
         const paneH = Math.max(4, Math.floor(H / rows));
         const out = [];
         for (let r = 0; r < rows; r++) {
-            const panes = ids.slice(r * cols, r * cols + cols).map((id) => this.pane(id, paneW, paneH, stats?.agents.get(id)));
+            const panes = ids.slice(r * cols, r * cols + cols).map((id) => this.pane(id, paneW, paneH, stats?.agents.get(id), views, now));
             for (let i = 0; i < paneH; i++)
                 out.push(panes.map((p) => p[i] ?? " ".repeat(paneW)).join(""));
         }
         return out;
     }
-    pane(id, w, h, a) {
+    pane(id, w, h, a, views, now) {
         const color = hexColor(id);
         const status = a?.busySince
-            ? `${C.violet("working")} ${fmtDuration(Date.now() - a.busySince)}${a.liveTokens > 0 ? " · " + fmtTokens(a.liveTokens) + " tok" : ""}`
-            : a && (a.tasks || a.reviews)
-                ? C.green(`done · ${a.tasks} task${a.tasks === 1 ? "" : "s"}${a.reviews ? ` + ${a.reviews} review` : ""}`)
+            ? `${C.violet("working")} ${fmtDuration(now - a.busySince)}${a.liveTokens > 0 ? " · " + fmtTokens(a.liveTokens) + " tok" : ""}`
+            : a && (a.tasks || a.reviews || a.qa)
+                ? C.green(`idle · ${a.tasks} merged${a.reviews ? ` · ${a.reviews} review${a.reviews === 1 ? "" : "s"}` : ""}${a.qa ? ` · ${a.qa} QA` : ""}`)
                 : C.faint("idle");
-        const title = ` ${dot(id)} ${C.bold(id)}  ${status} `;
         const inner = w - 2;
+        const title = truncate(` ${dot(id)} ${C.bold(id)}  ${status} `, inner - 1);
         const topLine = color("╭─") + title + color("─".repeat(Math.max(0, inner - 1 - width(title))) + "╮");
-        const lines = this.feed.filter((x) => x.agent === id).slice(-(h - 2));
+        // The task it's on stays pinned at the top: title, %, how long since it last said anything.
+        const on = a?.busySince ? views.find((v) => v.owner === id && (v.status === "claimed" || v.status === "in_progress")) : undefined;
+        const pinned = [];
+        if (on) {
+            const pct = on.reported ? C.violet(`${on.progress_pct}%`) : C.faint("no report yet");
+            const said = on.last_note ? C.faint(` · note ${fmtDuration(on.last_update_s * 1000)} ago`) : "";
+            const tail = `  ${pct}${said}`;
+            pinned.push(`${C.violet("▸")} ${C.bold(truncate(on.title, Math.max(8, inner - 4 - width(tail))))}${tail}`);
+        }
+        const room = h - 2 - pinned.length;
+        const lines = [...pinned, ...this.feed.filter((x) => x.agent === id).slice(-room).map((x) => x.text)];
         const body = Array.from({ length: h - 2 }, (_, i) => {
-            const l = lines[i] ? " " + truncate(lines[i].text, inner - 2) : "";
+            const l = lines[i] ? " " + truncate(lines[i], inner - 2) : "";
             return color("│") + pad(l, inner) + color("│");
         });
         return [topLine, ...body, color("╰" + "─".repeat(inner) + "╯")];
     }
-    /** Tab 2: the plan on the left, the room talking on the right. */
+    /** Tab 2: the plan, and the room talking (side by side when there's room, stacked when not). */
     plan(W, H, db) {
-        const leftW = Math.floor(W * 0.55);
         const left = [C.violet(" PLAN")];
-        const tasks = db?.listTasks() ?? [];
+        let tasks = [];
+        try {
+            tasks = db?.listTasks() ?? [];
+        }
+        catch {
+            /* a closed db */
+        }
         const idx = new Map(tasks.map((t, i) => [t.id, i + 1]));
         tasks.forEach((t, i) => {
             const deps = JSON.parse(t.depends_on || "[]");
             const after = deps.length ? C.faint(` after ${deps.map((d) => idx.get(d)).join(",")}`) : "";
             const who = t.claimed_by ? ` ${dot(t.claimed_by)} ${C.faint(t.claimed_by)}` : "";
-            left.push(` ${C.faint(String(i + 1) + ".")} ${t.title}${after}${who}`);
-            left.push(C.faint(`    ${t.status}`));
+            left.push(` ${mark(t.status, !!t.claimed_by)} ${C.faint(String(i + 1).padStart(2) + ".")} ${t.title}${after}${who}`);
         });
         if (!tasks.length)
             left.push(C.faint("  no plan yet"));
+        let contract = null;
+        try {
+            contract = db ? getContract(db) : null;
+        }
+        catch {
+            /* a closed db: no contract line */
+        }
+        if (contract && (contract.text || contract.amendments.length)) {
+            left.push("", `${C.violet(" CONTRACT")} ${C.faint(`v${contract.version} · ${contract.amendments.length} amendment(s)`)}`);
+            for (const a of contract.amendments.slice(-3))
+                left.push(C.faint(`   v${a.version} ${a.by}: ${a.section}: ${a.change}`));
+        }
         const right = [C.violet(" ROOM") + C.faint(" · agents & people talking")];
         for (const a of this.feed.filter((x) => !x.agent).slice(-(H - 1)))
             right.push(" " + a.text);
-        return columns(left, right, leftW, W, H);
+        if (right.length === 1)
+            right.push(C.faint("  nothing said yet"));
+        return columns(left, right, W, H, true);
     }
-    /** Tab 3: progress on the left, shared memory on the right. */
+    /** Tab 3: progress, and the shared screen + memory. */
     board(W, H, db) {
-        const leftW = Math.floor(W * 0.55);
         const left = [C.violet(" BOARD") + C.faint(" · live progress")];
-        for (const t of db?.listTasks() ?? []) {
-            const bw = 14;
+        let views = [];
+        try {
+            views = db ? taskViews(db) : [];
+        }
+        catch {
+            /* a closed db */
+        }
+        const bw = W >= 100 ? 14 : 8;
+        for (const t of views) {
             const filled = Math.round((t.progress_pct / 100) * bw);
             const barS = t.status === "merged" ? C.green("█".repeat(bw)) : C.violet("█".repeat(filled)) + C.faint("░".repeat(bw - filled));
-            const st = t.status === "merged" ? C.green("✓") : t.status === "failed" ? C.red("✗") : t.status === "needs_you" ? C.yellow("!") : t.claimed_by ? C.violet("▸") : C.faint("○");
-            left.push(` ${st} ${barS} ${String(t.progress_pct).padStart(3)}%  ${t.title}`);
-            if (t.claimed_by)
-                left.push(C.faint(`                        ${t.claimed_by}`));
-        }
-        const right = [C.violet(" SHARED MEMORY") + C.faint(" · everyone reads & writes")];
-        for (const m of (db?.recall() ?? []).slice(0, H - 1)) {
-            right.push(` ${C.faint("•")} ${m.body}`);
+            // Never reported (no huddle_progress yet): say so instead of showing a made-up 0%.
+            const silent = ["claimed", "in_progress"].includes(t.status) && !t.reported;
+            const who = t.owner ? ` ${dot(t.owner)} ${C.faint(t.owner)}` : "";
+            left.push(` ${mark(t.status, !!t.owner)} ${barS} ${silent ? C.faint("  — ") : String(t.progress_pct).padStart(3) + "%"}  ${t.title}${who}`);
+        }
+        if (!views.length)
+            left.push(C.faint("  no tasks yet"));
+        const right = [];
+        // The shared screen: what the user put up, and the notes pinned on it.
+        let screen = [];
+        let memory = [];
+        try {
+            screen = db ? screenPanel(db, Math.min(8, Math.floor(H / 2))) : [];
+            memory = db?.recall() ?? [];
+        }
+        catch {
+            /* a closed db */
+        }
+        if (screen.length)
+            right.push(C.violet(" SCREEN") + C.faint(" · pastes & files every agent reads"), ...screen.map((l) => " " + screenGlyphs(l)), "");
+        right.push(C.violet(" SHARED MEMORY") + C.faint(" · everyone reads & writes"));
+        for (const m of memory.slice(0, H - 1)) {
+            right.push(` ${C.violet("◆")} ${m.author ? C.faint(m.author + ": ") : ""}${m.body}`);
             if (m.why)
                 right.push(C.faint(`   why: ${m.why}`));
         }
-        return columns(left, right, leftW, W, H);
+        if (!memory.length)
+            right.push(C.faint("  nothing yet"));
+        return columns(left, right, W, H);
     }
 }
-function columns(left, right, leftW, W, H) {
+/** A task's state as one glyph, the same ones the run's output uses. */
+function mark(status, claimed) {
+    if (status === "merged")
+        return C.green("✓");
+    if (status === "failed")
+        return C.red("✗");
+    if (status === "needs_you")
+        return C.yellow("!");
+    if (status === "review")
+        return C.violet("◎");
+    return claimed ? C.violet("▸") : C.faint("○");
+}
+/** Two columns side by side on a wide screen; on a narrow one, the left on top of the right. */
+function columns(left, right, W, H, latest = false) {
+    if (W < 100) {
+        const top = left.slice(0, Math.max(3, Math.min(left.length, H - Math.min(right.length, Math.floor(H / 2)) - 1)));
+        const n = Math.max(0, H - top.length - 1);
+        // A feed keeps its newest lines (its header stays).
+        const rest = latest && right.length > n ? [right[0], ...right.slice(1).slice(-(n - 1))].slice(0, n) : right.slice(0, n);
+        return [...top, C.faint("─".repeat(W)), ...rest].map((l) => truncate(l, W));
+    }
+    const leftW = Math.floor(W * 0.55);
     const out = [];
     for (let i = 0; i < H; i++) {
         const l = truncate(left[i] ?? "", leftW - 1);

package/dist/ui/doctor.js

@@ -6,7 +6,8 @@ import { spawnSync } from "node:child_process";
 import { LEGACY } from "../adapters/index.js";
 import { packageInfo } from "../preflight.js";
 import { sqliteStatus } from "../room/sqlite.js";
-import { connectAgents } from "./app.js";
+import { connectAgents, installLine } from "./app.js";
+import { gitFix } from "../platform.js";
 import { C, dot } from "./term.js";
 export async function runDoctor() {
     let blocked = false;
@@ -23,7 +24,7 @@ export async function runDoctor() {
     if (gitNum === null) {
         blocked = true;
         console.log(C.red("\n✗ git isn't installed.") + " Huddle gives every agent its own git worktree.");
-        console.log(C.faint("  macOS: xcode-select --install  ·  Debian/Ubuntu: sudo apt install git  ·  https://git-scm.com"));
+        console.log(C.faint("  " + gitFix()));
     }
     if (!db.ok) {
         blocked = true;
@@ -35,20 +36,23 @@ export async function runDoctor() {
     return blocked ? 1 : 0;
 }
 /** What to do when agents are missing or signed out. Returns true if at least one is ready. */
-function nextSteps(results) {
+export function nextSteps(results, print = console.log) {
     const ready = results.filter((r) => r.state === "ready");
+    const pending = results.filter((r) => r.state === "not_authed" || (r.state === "not_installed" && !LEGACY.has(r.adapter.id)));
     if (ready.length) {
-        console.log(C.faint(`\n  ${ready.length} agent(s) ready — cd into a repo and run: huddle`));
+        print(C.faint(`\n  ${ready.length} agent(s) ready — cd into a repo and run: huddle`));
+        if (pending.length)
+            print(C.faint(`  set up the rest (${pending.map((r) => r.adapter.id).join(", ")}): huddle setup`));
         return true;
     }
     const missing = results.filter((r) => r.state === "not_installed" && !LEGACY.has(r.adapter.id));
-    console.log(`\n${C.yellow("No agents ready yet.")} Huddle runs the coding agents you already use, each signed in to its own account.`);
-    if (missing.length) {
-        console.log(C.faint("  Install one or more (or run `huddle` — it offers to, and asks first):"));
-        for (const r of missing)
-            console.log(`    ${dot(r.adapter.id)} ${C.bold(r.adapter.id.padEnd(12))} ${C.faint("$")} ${r.adapter.install.cmd}`);
-    }
-    console.log(C.faint("  Then sign in with the agent itself — Huddle never sees your credentials — and run `huddle doctor` again."));
+    print(`\n${C.yellow("No agents ready yet.")} Huddle runs the coding agents you already use,`);
+    print("each signed in to its own account.");
+    print(`  ${C.bold("huddle setup")} ${C.faint("installs and signs in the ones you pick (asks first). Or by hand:")}`);
+    for (const r of missing)
+        print(`    ${dot(r.adapter.id)} ${C.bold(r.adapter.id.padEnd(12))} ${C.faint("$")} ${installLine(r.adapter)}`);
+    print(C.faint("  Then sign in with the agent itself — Huddle never sees your credentials —"));
+    print(C.faint("  and run `huddle doctor` again."));
     return false;
 }
 //# sourceMappingURL=doctor.js.map

package/dist/ui/lessons.js

@@ -0,0 +1,81 @@
+// `huddle lessons`: what Huddle learned across runs on this machine, and how
+// to take a lesson back.
+//
+//   huddle lessons                 list them, most-seen first
+//   huddle lessons --forget <id>   drop one
+//   huddle lessons --clear [--yes] drop all (asks first)
+import readline from "node:readline/promises";
+import os from "node:os";
+import { C } from "./term.js";
+import { allLessons, clearLessons, forgetLesson, lessonsFile, lessonsOff, repoKey } from "../room/lessons.js";
+const ago = (ts) => {
+    const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+    return s < 90 ? `${s}s ago` : s < 5400 ? `${Math.round(s / 60)}m ago` : s < 129600 ? `${Math.round(s / 3600)}h ago` : `${Math.round(s / 86400)}d ago`;
+};
+function scopeLabel(l, here) {
+    if (l.scope === "all")
+        return "every run";
+    if (l.scope.startsWith("agent:"))
+        return l.scope.slice(6);
+    return here && l.scope === `repo:${here}` ? "this repo" : `repo ${l.scope.slice(5, 13)}`;
+}
+export async function runLessons(rest, cwd = process.cwd()) {
+    const file = lessonsFile().replace(os.homedir(), "~");
+    const fi = rest.indexOf("--forget");
+    if (fi >= 0) {
+        const id = rest[fi + 1];
+        if (!id || id.startsWith("--")) {
+            console.log(C.red("✗ --forget needs a lesson id") + C.faint(" (the first column of `huddle lessons`)"));
+            process.exitCode = 1;
+            return;
+        }
+        if (!forgetLesson(id)) {
+            console.log(C.red(`✗ no lesson ${id}`) + C.faint(" — `huddle lessons` lists them"));
+            process.exitCode = 1;
+            return;
+        }
+        return void console.log(`${C.green("✓")} forgot ${id}`);
+    }
+    if (rest.includes("--clear")) {
+        const n = allLessons().length;
+        if (!n)
+            return void console.log(C.faint("No lessons to clear."));
+        if (!rest.includes("--yes")) {
+            if (!process.stdin.isTTY) {
+                console.log(C.yellow(`! this deletes all ${n} lesson(s) in ${file}.`) + " Run it again with --yes to confirm.");
+                process.exitCode = 1;
+                return;
+            }
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const a = (await rl.question(`Delete all ${n} lesson(s) in ${file}? ${C.faint("[y/N]")} `)).trim().toLowerCase();
+            rl.close();
+            if (!a.startsWith("y"))
+                return void console.log(C.faint("Kept them."));
+        }
+        clearLessons();
+        return void console.log(`${C.green("✓")} cleared ${n} lesson(s)`);
+    }
+    const lessons = allLessons().sort((a, b) => b.hits - a.hits || b.created - a.created);
+    if (lessonsOff())
+        console.log(C.yellow("! HUDDLE_NO_LESSONS is set: runs neither use nor learn lessons right now."));
+    if (!lessons.length) {
+        console.log(`No lessons yet ${C.faint(`(${file})`)}.`);
+        console.log(C.faint("  Huddle learns them at the end of each run — a council turn that timed out, a file agents collided on, QA bugs — and agents add them with huddle_remember(kind=\"lesson\")."));
+        return;
+    }
+    let here = null;
+    try {
+        here = repoKey(cwd);
+    }
+    catch {
+        /* not in a repo */
+    }
+    console.log(`${C.violet("lessons")} ${C.faint(`· ${lessons.length} · ${file} · they go into agent and planner prompts`)}\n`);
+    for (const l of lessons) {
+        console.log(`  ${C.bold(l.id)}  ${l.text}`);
+        const used = l.last_used ? `used ${ago(l.last_used)}` : "not used yet";
+        console.log(C.faint(`            ${scopeLabel(l, here)} · seen ${l.hits}× · ${used} · from ${l.source || "?"}${l.evidence ? ` · ${l.evidence}` : ""}`));
+    }
+    console.log(C.faint(`\n  huddle lessons --forget <id> · --clear · HUDDLE_NO_LESSONS=1 turns them off`));
+}
+//# sourceMappingURL=lessons.js.map