huddle-cli 0.0.0-stage → 0.1.1

package/dist/ui/catalog.js

@@ -0,0 +1,113 @@
+// `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 { ADAPTERS, AGENTS_FILE_ERRORS, BUILTIN_ADAPTERS, LEGACY, installCommand, noInstallHint, probe } from "../adapters/index.js";
+import { agentsFiles } from "../adapters/custom.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(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`);
+    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. */
+export async function installConnector(id) {
+    const a = all().find((x) => x.id === id);
+    if (!a) {
+        console.log(C.red(`✗ no connector called ${id}.`) + " See `huddle agents --all`.");
+        return false;
+    }
+    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  ${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("$ " + cmd)}`);
+        const ans = (await rl.question(`Install ${a.id}? ${C.faint("[Y/n]")} `)).trim().toLowerCase();
+        if (ans && !ans.startsWith("y"))
+            return false;
+        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}`));
+                runInteractive(rl, a.install.login);
+            }
+        }
+        return ok;
+    }
+    finally {
+        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

@@ -0,0 +1,335 @@
+// The live view — the full-screen dashboard from the launch film.
+//
+//   ⬢ 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. 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";
+    open = false;
+    timer;
+    feed = [];
+    onKey;
+    constructor(src) {
+        this.src = src;
+    }
+    isOpen() {
+        return this.open;
+    }
+    /** Keep a rolling log whether or not the view is on screen. */
+    push(a) {
+        this.feed.push({ ...a, ts: Date.now() });
+        if (this.feed.length > 400)
+            this.feed.splice(0, this.feed.length - 400);
+        if (this.open)
+            this.render();
+    }
+    show(tab, onClose) {
+        if (!process.stdout.isTTY)
+            return;
+        if (tab)
+            this.tab = tab;
+        if (this.open)
+            return this.render();
+        this.open = true;
+        process.stdout.write("\x1b[?1049h\x1b[?25l"); // alternate screen, hide cursor
+        this.onKey = (s, key) => {
+            if (!this.open)
+                return;
+            const k = key?.name ?? s;
+            if (s === "1")
+                this.tab = "agents";
+            else if (s === "2")
+                this.tab = "plan";
+            else if (s === "3")
+                this.tab = "board";
+            else if (k === "tab")
+                this.tab = this.tab === "agents" ? "plan" : this.tab === "plan" ? "board" : "agents";
+            else if (s === "q" || k === "escape" || (key?.ctrl && key.name === "t")) {
+                this.hide();
+                onClose?.();
+                return;
+            }
+            this.render();
+        };
+        process.stdin.on("keypress", this.onKey);
+        process.stdout.on("resize", this.renderBound);
+        this.timer = setInterval(() => this.render(), 500);
+        this.render();
+    }
+    hide() {
+        if (!this.open)
+            return;
+        this.open = false;
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.onKey)
+            process.stdin.off("keypress", this.onKey);
+        process.stdout.off("resize", this.renderBound);
+        process.stdout.write("\x1b[?25h\x1b[?1049l"); // back to the normal screen
+    }
+    renderBound = () => this.render();
+    render() {
+        if (!this.open)
+            return;
+        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 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 === tab ? C.bold(C.violet(`[${i + 1} ${t}]`)) : C.faint(` ${i + 1} ${t} `)))
+            .join(" ");
+        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}`;
+        // 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 = 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 ? ` ${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, 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(`  ${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), 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, views, now) {
+        const color = hexColor(id);
+        const status = a?.busySince
+            ? `${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 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))) + "╮");
+        // 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], inner - 2) : "";
+            return color("│") + pad(l, inner) + color("│");
+        });
+        return [topLine, ...body, color("╰" + "─".repeat(inner) + "╯")];
+    }
+    /** Tab 2: the plan, and the room talking (side by side when there's room, stacked when not). */
+    plan(W, H, db) {
+        const left = [C.violet(" PLAN")];
+        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(` ${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);
+        if (right.length === 1)
+            right.push(C.faint("  nothing said yet"));
+        return columns(left, right, W, H, true);
+    }
+    /** Tab 3: progress, and the shared screen + memory. */
+    board(W, H, db) {
+        const left = [C.violet(" BOARD") + C.faint(" · live progress")];
+        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));
+            // 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}`));
+        }
+        if (!memory.length)
+            right.push(C.faint("  nothing yet"));
+        return columns(left, right, 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);
+        const r = truncate(right[i] ?? "", W - leftW - 2);
+        out.push(pad(l, leftW - 1) + C.faint("│") + " " + r);
+    }
+    return out;
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/ui/doctor.js

@@ -0,0 +1,58 @@
+// `huddle doctor`: is this machine ready? Huddle itself (Node, git, the room
+// database), then your agents — and, when something's missing, the exact next
+// command. Read-only: it never installs or signs in; `huddle` offers that (and
+// asks first). Exit code 1 when Huddle can't run a goal here yet.
+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, installLine } from "./app.js";
+import { gitFix } from "../platform.js";
+import { C, dot } from "./term.js";
+export async function runDoctor() {
+    let blocked = false;
+    const gitV = spawnSync("git", ["--version"], { encoding: "utf8" });
+    const gitNum = gitV.status === 0 ? (gitV.stdout.match(/\d+\.\d+(\.\d+)?/)?.[0] ?? "") : null;
+    const db = sqliteStatus();
+    const parts = [
+        `${C.violet("huddle")} ${packageInfo().version}`,
+        `node ${process.versions.node}`,
+        gitNum === null ? C.red("git missing") : `git ${gitNum}`.trim(),
+        db.ok ? `room db: ${db.driver}` : C.red("room db: unavailable"),
+    ];
+    console.log("\n  " + parts.join(C.faint("  ·  ")));
+    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("  " + gitFix()));
+    }
+    if (!db.ok) {
+        blocked = true;
+        console.log("\n" + C.red("✗ ") + db.message);
+    }
+    const results = await connectAgents();
+    if (!nextSteps(results))
+        blocked = true;
+    return blocked ? 1 : 0;
+}
+/** What to do when agents are missing or signed out. Returns true if at least one is ready. */
+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) {
+        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));
+    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

package/dist/ui/logo.js

@@ -0,0 +1,40 @@
+// The Huddle mark (teaser/assets/huddle-logo.svg: four heavy rings in a plus)
+// rasterized to half-block characters (▀ ▄ █). Each cell is one pixel wide and
+// two tall, so pixels come out square and the rings render solid in any font.
+const RINGS = [
+    [0, -43.5],
+    [43.5, 0],
+    [0, 43.5],
+    [-43.5, 0],
+];
+const R = 56;
+const HALF_STROKE = 11;
+const VIEW = 224; // svg viewBox is -112..112
+const inRing = (x, y) => RINGS.some(([cx, cy]) => Math.abs(Math.hypot(x - cx, y - cy) - R) <= HALF_STROKE);
+/** Fraction of pixel (px, py) on a W×H grid covered by the rings. */
+function coverage(px, py, W, H, ss = 6) {
+    let hits = 0;
+    for (let i = 0; i < ss; i++)
+        for (let j = 0; j < ss; j++) {
+            const x = -VIEW / 2 + ((px + (i + 0.5) / ss) / W) * VIEW;
+            const y = -VIEW / 2 + ((py + (j + 0.5) / ss) / H) * VIEW;
+            if (inRing(x, y))
+                hits++;
+        }
+    return hits / (ss * ss);
+}
+/** Render the logo as `rows` lines of `cols` cells. 16×8 is the tuned size. */
+export function logoLines(cols = 16, rows = 8, threshold = 0.42) {
+    const out = [];
+    for (let r = 0; r < rows; r++) {
+        let line = "";
+        for (let c = 0; c < cols; c++) {
+            const top = coverage(c, r * 2, cols, rows * 2) >= threshold;
+            const bot = coverage(c, r * 2 + 1, cols, rows * 2) >= threshold;
+            line += top && bot ? "█" : top ? "▀" : bot ? "▄" : " ";
+        }
+        out.push(line);
+    }
+    return out;
+}
+//# sourceMappingURL=logo.js.map