huddle-cli 0.1.0 → 0.1.3

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/narrator.js

@@ -0,0 +1,56 @@
+// One plain-English line on top of a live run: what's happening now, and
+// whether you're needed.
+//
+// Found live (0.1.2 test): with four agents' notes scrolling by, the user
+// couldn't tell what the team was doing, or whether it was waiting on them.
+// The narrator answers both, every second, with words, not engineering:
+//   Now: the agents are each sketching how they'd build it · nothing needed from you
+//   Now: building — 2 of 8 parts done · claude: argv parser · codex: conversion core 25%
+//   ⚑ claude has a question for you — answer below · picks option 1 in 41s
+import { fmtDuration } from "../adapters/usage.js";
+import { C, truncate } from "./term.js";
+const COUNCIL = {
+    1: "the agents are each sketching how they'd build it",
+    2: "they're reading each other's ideas: what to borrow, what could go wrong",
+    3: "one agent is writing the plan from the best ideas",
+    4: "the others are double-checking the plan before anyone writes code",
+};
+/** "Build strict positional argv parser with UsageError" → "strict positional argv parser". */
+function shortTitle(t, n = 32) {
+    const s = t.replace(/^(build|create|write|add|implement|make|set up)\s+(the\s+|a\s+|an\s+)?/i, "").replace(/\s+(with|and|for|that)\s.*$/i, "");
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+/** The narrator's words for the run as it stands (no colors), and whether it's waiting on you. */
+export function narration(stats, now = Date.now()) {
+    const ask = stats.ask;
+    if (ask && ask.until > now)
+        return { needsYou: true, text: `${ask.from} has a question for you — answer below · picks option 1 in ${fmtDuration(ask.until - now)}` };
+    const r = stats.run;
+    if (!r)
+        return { needsYou: false, text: "getting started" };
+    if (r.phase === "COUNCIL")
+        return { needsYou: false, text: COUNCIL[r.step ?? 1] ?? COUNCIL[1] };
+    if (r.phase === "PLAN")
+        return { needsYou: false, text: "splitting the work into parts" };
+    if (r.phase === "DONE")
+        return { needsYou: false, text: "done — the summary is below" };
+    const busy = [...stats.agents].filter(([, a]) => a.busySince && a.doing);
+    const who = busy.map(([id, a]) => `${id}: ${shortTitle(a.doing)}${a.pct ? ` ${a.pct}%` : ""}`);
+    if (r.phase === "QA")
+        return { needsYou: false, text: `testing the finished build: agents try to break parts they didn't write${r.round ? ` (round ${r.round})` : ""}${who.length ? " · " + who.join(" · ") : ""}` };
+    const done = r.total ? `${r.done} of ${r.total} parts done` : "starting";
+    return { needsYou: false, text: `building — ${done}${r.failed ? `, ${r.failed} stuck` : ""}${who.length ? " · " + who.join(" · ") : ""}` };
+}
+/** The narrator line, cut to `W` cells: "  Now: … · nothing needed from you". */
+export function narratorLine(stats, W, now = Date.now()) {
+    const n = narration(stats, now);
+    if (n.needsYou)
+        return truncate(`  ${C.yellow("⚑ " + n.text)}`, W);
+    const calm = C.faint(" · nothing needed from you");
+    const head = `  ${C.bold(C.violet("Now:"))} `;
+    // The reassurance stays; the detail gives way.
+    const room = W - 2 - 5 - 27;
+    const text = n.text.length > room && room > 12 ? n.text.slice(0, room - 1) + "…" : n.text;
+    return truncate(`${head}${text}${calm}`, W);
+}
+//# sourceMappingURL=narrator.js.map

package/dist/ui/paste.js

@@ -0,0 +1,515 @@
+// Pasting at the `huddle ›` prompt, and the commands that put things on the
+// shared screen (src/room/context.ts).
+//
+// readline fires one "line" per pasted line, so a pasted stack trace used to
+// run as 200 goals. Here the paste is caught BEFORE readline sees it:
+//
+//   bracketed paste  the terminal wraps a paste in ESC[200~ … ESC[201~ (we turn
+//                    that on with ESC[?2004h) — everything inside is one input
+//   fallback         a terminal without it: text that arrives in one burst
+//                    (a newline plus more, chunks < 30 ms apart) is one paste
+//
+// A short paste (≤ 3 lines, ≤ 500 chars) goes back to the line as typed, on
+// one line. A long one becomes a screen item; what you type next is the goal.
+import { StringDecoder } from "node:string_decoder";
+import fs from "node:fs";
+import path from "node:path";
+import { RoomDB } from "../room/db.js";
+import { ContextStore, brainSummary, droppedPaths, expandGlob, fmtBytes, isGlob, looksText as looksTextBuf, redactSecrets, splitPathTokens, } from "../room/context.js";
+import { C } from "./term.js";
+export const PASTE_START = "\x1b[200~";
+export const PASTE_END = "\x1b[201~";
+/** Ask the terminal to mark pastes (or stop, before handing it to another program). */
+export function bracketedPaste(on, out = process.stdout) {
+    if (out.isTTY)
+        out.write(on ? "\x1b[?2004h" : "\x1b[?2004l");
+}
+/** Long enough to be a screen item rather than part of the line. */
+export function isLongPaste(text) {
+    const t = text.replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+    return t.split("\n").length > 3 || t.length > 500;
+}
+/** A short multi-line paste, as one typed line. */
+export const flatten = (text) => text.replace(/\r\n?|\n/g, " ").replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "").replace(/\s+$/, "");
+/** How many chars at the end of `s` could be the start of `marker`. */
+function partialTail(s, marker) {
+    for (let k = Math.min(marker.length - 1, s.length); k > 0; k--)
+        if (s.endsWith(marker.slice(0, k)))
+            return k;
+    return 0;
+}
+/**
+ * Splits terminal input into typed text (passed through to readline) and
+ * pastes (handed to onPaste). Pure apart from its timers, so tests feed it
+ * chunks directly.
+ */
+export class PasteCatcher {
+    o;
+    inPaste = false;
+    buf = "";
+    tail = "";
+    burst = "";
+    burstTimer = null;
+    tailTimer = null;
+    constructor(o) {
+        this.o = o;
+    }
+    feed(chunk) {
+        if (this.o.enabled && !this.o.enabled() && !this.inPaste) {
+            this.flushBurst();
+            return this.o.pass(this.takeTail() + chunk);
+        }
+        let s = this.takeTail() + chunk;
+        while (s) {
+            if (this.inPaste) {
+                const j = s.indexOf(PASTE_END);
+                if (j < 0) {
+                    const k = partialTail(s, PASTE_END);
+                    this.buf += s.slice(0, s.length - k);
+                    this.holdTail(s.slice(s.length - k));
+                    return;
+                }
+                this.buf += s.slice(0, j);
+                s = s.slice(j + PASTE_END.length);
+                this.inPaste = false;
+                const text = this.buf;
+                this.buf = "";
+                if (text)
+                    this.o.onPaste(text);
+                continue;
+            }
+            const i = s.indexOf(PASTE_START);
+            if (i < 0) {
+                const k = partialTail(s, PASTE_START);
+                if (s.length - k)
+                    this.typed(s.slice(0, s.length - k));
+                this.holdTail(s.slice(s.length - k));
+                return;
+            }
+            if (i > 0)
+                this.typed(s.slice(0, i));
+            this.flushBurst();
+            s = s.slice(i + PASTE_START.length);
+            this.inPaste = true;
+        }
+    }
+    takeTail() {
+        const t = this.tail;
+        this.tail = "";
+        if (this.tailTimer)
+            clearTimeout(this.tailTimer);
+        this.tailTimer = null;
+        return t;
+    }
+    /** A lone ESC (the escape key) may be a marker's start: wait a moment, then let it through. */
+    holdTail(t) {
+        this.tail = t;
+        if (!t)
+            return;
+        this.tailTimer = setTimeout(() => {
+            this.tailTimer = null;
+            const held = this.tail;
+            this.tail = "";
+            if (!held)
+                return;
+            if (this.inPaste)
+                this.buf += held;
+            else
+                this.typed(held);
+        }, 25);
+    }
+    /** The fallback: a newline plus more in one chunk — or chunks right behind it — is a paste. */
+    typed(t) {
+        if (this.burstTimer) {
+            this.burst += t;
+            this.armBurst();
+            return;
+        }
+        if (t.length > 1 && /[\r\n]/.test(t)) {
+            this.burst = t;
+            this.armBurst();
+            return;
+        }
+        this.o.pass(t);
+    }
+    armBurst() {
+        if (this.burstTimer)
+            clearTimeout(this.burstTimer);
+        this.burstTimer = setTimeout(() => this.flushBurst(), this.o.windowMs ?? 30);
+    }
+    flushBurst() {
+        if (this.burstTimer)
+            clearTimeout(this.burstTimer);
+        this.burstTimer = null;
+        const b = this.burst;
+        this.burst = "";
+        if (!b)
+            return;
+        // One line + Enter that arrived in one chunk (a laggy terminal) is still typing.
+        const body = b.replace(/[\r\n]+$/, "");
+        if (/[\r\n]/.test(body))
+            this.o.onPaste(body);
+        else
+            this.o.pass(b);
+    }
+}
+/**
+ * Put a catcher in front of stdin: every "data" chunk goes through it before
+ * readline (and keypress listeners) see anything. Returns the undo.
+ */
+export function interceptStdin(stdin, make) {
+    const orig = stdin.emit;
+    const decoder = new StringDecoder("utf8");
+    const pass = (s) => void orig.call(stdin, "data", Buffer.from(s, "utf8"));
+    const catcher = make(pass);
+    stdin.emit = function (ev, ...args) {
+        if (ev !== "data")
+            return orig.apply(this, [ev, ...args]);
+        const c = args[0];
+        catcher.feed(typeof c === "string" ? c : decoder.write(c));
+        return true;
+    };
+    return () => {
+        stdin.emit = orig;
+    };
+}
+const q = (s) => `'${s.length > 40 ? s.slice(0, 39) + "…" : s}'`;
+const sizeWord = (i) => (i.lines && (i.kind === "text" || i.kind === "code") ? `${i.lines} line${i.lines === 1 ? "" : "s"}` : fmtBytes(i.bytes));
+/** Secrets found → ask (or, with nobody to ask, redact) → save. */
+async function save(store, p, ui) {
+    let redact = true;
+    if (p.secrets.length) {
+        const kinds = [...new Set(p.secrets.map((h) => h.kind))].join(", ");
+        const { agents, companies } = ui.audience();
+        const who = agents.length ? `${agents.join(", ")} (${companies} compan${companies === 1 ? "y" : "ies"})` : "every agent in the room";
+        ui.print(C.yellow(`  ⚠ ${p.secrets.length} likely secret${p.secrets.length > 1 ? "s" : ""} in ${q(p.title)}: ${kinds} (line ${p.secrets.slice(0, 3).map((h) => h.line).join(", ")})`));
+        if (ui.interactive)
+            redact = await ui.yes(`  this will be shown to ${who} — redact?`, true);
+        else
+            ui.print(C.faint(`  redacted before it goes to ${who}`));
+    }
+    const res = store.commit(p, { by: "you", redact, announce: ui.announce });
+    if (res.ok && !res.duplicate && res.item.lines > 200 && ui.brain) {
+        // A one-line brain summary for the index — in the background, never blocking the prompt.
+        void brainSummary(store, res.item, ui.brain(), ui.root?.() ?? process.cwd()).catch(() => { });
+    }
+    return res;
+}
+/** Print what happened to an add; true if the item is on the screen. */
+function report(res, ui, verb) {
+    if (!res.ok) {
+        ui.print(C.red(`  ✗ ${res.reason}`));
+        return false;
+    }
+    const i = res.item;
+    if (res.duplicate) {
+        ui.print(`  📎 already on the screen: ${i.id} ${q(i.title)}`);
+        return true;
+    }
+    // "📎 pasted 214 lines (ctx-3 'TypeError…')" · "📎 added 'shot.png' (ctx-4 · image · 412 KB · 1280×720)"
+    if (verb === "added")
+        ui.print(`  📎 added ${q(i.title)} ${C.faint(`(${i.id} · ${i.kind} · ${i.lines ? sizeWord(i) + ", " : ""}${fmtBytes(i.bytes)}${i.summary ? " · " + i.summary.slice(0, 60) : ""})`)}`);
+    else
+        ui.print(`  📎 ${verb} ${sizeWord(i)} ${C.faint(`(${i.id} ${q(i.title)})`)}`);
+    if (res.redacted)
+        ui.print(C.faint(`     ${res.redacted} secret${res.redacted > 1 ? "s" : ""} redacted`));
+    for (const w of res.warnings ?? [])
+        ui.print(C.faint(`     ${w}`));
+    if (res.announced?.length)
+        ui.print(C.faint(`     told ${res.announced.join(", ")} (working now)`));
+    return true;
+}
+/** A long paste → a screen item. Returns false if it should go back to the line instead. */
+export async function pasteToScreen(text, ui) {
+    const db = await ui.db();
+    if (!db) {
+        ui.print(C.yellow("  ! pastes go on a repo's shared screen — cd into a git repo first"));
+        return true;
+    }
+    const store = ContextStore.open(db);
+    const p = store.prepareText(text);
+    if ("ok" in p) {
+        ui.print(C.red(`  ✗ ${p.reason}`));
+        return true;
+    }
+    const res = await save(store, p, ui);
+    report(res, ui, "pasted");
+    if (res.ok && !res.duplicate)
+        ui.print(C.faint("     type your goal — every agent sees it on the shared screen, not in N copies"));
+    return true;
+}
+/** A dropped file path (or several): the whole line is existing absolute paths. */
+export function asDrop(text) {
+    return droppedPaths(text.replace(/\r?\n/g, " "));
+}
+/**
+ * `add a login page` is a goal; `add ./log.txt`, `add *.png`, `add ~/shot.png`,
+ * `add notes.md` (when it exists) add files. A bare missing name ("add
+ * README.md") is a goal: the user wants it written.
+ */
+export function looksLikePaths(rest, cwd = process.cwd()) {
+    const toks = splitPathTokens(rest);
+    if (!toks.length)
+        return false;
+    return toks.every((t) => isGlob(t) || /[\\/~]|^\./.test(t) || (/\.\w{1,8}$/.test(t) && fs.existsSync(path.resolve(cwd, t))));
+}
+/** A Room event as a line for the prompt and/or the live view (null = not a screen event). */
+export function screenEvent(e) {
+    if (!e.type.startsWith("context."))
+        return null;
+    let p = {};
+    try {
+        p = JSON.parse(e.payload || "{}");
+    }
+    catch {
+        return null;
+    }
+    const t = q(String(p.title ?? ""));
+    if (e.type === "context.note") {
+        const text = `📌 ${C.bold(p.by)} on ${p.id} ${C.faint(t)}: ${p.body}`;
+        return { print: p.by === "you" ? undefined : `  ${text}`, dash: { text } };
+    }
+    if (e.type === "context.added" && p.by !== "you") {
+        const text = `📎 ${C.bold(p.by)} put ${p.id} on the screen: ${t}`;
+        return { print: `  ${text}`, dash: { text } };
+    }
+    if (e.type === "context.read" && e.agent_id)
+        return { dash: { agent: e.agent_id, text: `📖 read ${p.id} ${t}${p.from ? ` lines ${p.from}-${p.to}` : ""}` } };
+    return null;
+}
+/**
+ * `add <path…|glob>`: files, folders (their text files, as one item) and
+ * globs (more than 5 matches → one item). Returns how many failed.
+ */
+export async function addPaths(args, ui, cwd = process.cwd()) {
+    const db = await ui.db();
+    if (!db) {
+        ui.print(C.red("  ✗ open a git repo first") + C.faint(" — the shared screen belongs to a project"));
+        return args.length || 1;
+    }
+    const store = ContextStore.open(db);
+    if (!args.length)
+        ui.print(C.faint("  usage: add <file|folder|glob> … — or just drag a file into this window"));
+    let failed = 0;
+    for (const a of args) {
+        // "shot [1].png" that exists is a file, not a pattern.
+        if (isGlob(a) && !fs.existsSync(path.resolve(cwd, a))) {
+            const hits = expandGlob(a, cwd);
+            if (!hits.length) {
+                ui.print(C.red(`  ✗ nothing matches ${a}`));
+                failed++;
+            }
+            else if (hits.length > 5) {
+                const p = store.prepareBundle(a, cwd, hits);
+                if ("ok" in p) {
+                    ui.print(C.red(`  ✗ ${p.reason}`));
+                    failed++;
+                }
+                else if (!report(await save(store, p, ui), ui, "added"))
+                    failed++;
+            }
+            else
+                for (const h of hits)
+                    if (!(await addOne(store, h, ui, cwd)))
+                        failed++;
+            continue;
+        }
+        if (!(await addOne(store, a, ui, cwd)))
+            failed++;
+    }
+    return failed;
+}
+async function addOne(store, p, ui, cwd) {
+    const prep = store.preparePath(p, cwd);
+    if ("ok" in prep) {
+        ui.print(C.red(`  ✗ ${prep.reason}`));
+        return false;
+    }
+    return report(await save(store, prep, ui), ui, "added");
+}
+/** `ctx` / `context`: list · show <id> · rm <id…> · note <id> <text> · add <path…> · clear */
+export async function ctxCommand(arg, ui) {
+    const db = await ui.db();
+    if (!db)
+        return ui.print(C.red("  ✗ open a git repo first") + C.faint(" — the shared screen belongs to a project"));
+    const store = ContextStore.open(db);
+    const [sub, ...rest] = arg.trim().split(/\s+/).filter(Boolean);
+    if (!sub || sub === "ls" || sub === "list") {
+        const items = store.list();
+        if (!items.length)
+            return ui.print(C.faint("  nothing on the shared screen — paste something long, drag a file in, or `add <file>`"));
+        ui.print(`\n  ${C.violet("SCREEN")} ${C.faint(`· ${items.length} item${items.length > 1 ? "s" : ""} · ${fmtBytes(store.totalBytes())} · agents read these on demand`)}`);
+        for (const i of items) {
+            ui.print(`  ${C.bold(i.id.padEnd(6))} ${i.kind.padEnd(5)} ${q(i.title)} ${C.faint(`· ${sizeWord(i)} · by ${i.added_by}${i.notes.length ? ` · ${i.notes.length} note${i.notes.length > 1 ? "s" : ""}` : ""}`)}`);
+            if (i.brain_summary || i.summary)
+                ui.print(C.faint(`         ${(i.brain_summary || i.summary).slice(0, 110)}`));
+            for (const n of i.notes.slice(-2))
+                ui.print(`         📌 ${C.bold(n.by)} ${n.body.slice(0, 110)}`);
+        }
+        return ui.print(C.faint("\n  ctx show <id> · ctx rm <id> · ctx note <id> <text> · add <file>"));
+    }
+    if (sub === "add")
+        return void (await addPaths(splitPathTokens(rest.join(" ")), ui));
+    if (sub === "clear") {
+        const items = store.list();
+        if (!items.length)
+            return ui.print(C.faint("  the screen is already empty"));
+        if (ui.interactive && !(await ui.yes(`  take all ${items.length} items off the screen?`, false)))
+            return;
+        for (const i of items)
+            store.remove(i.id);
+        return ui.print(`  ${C.green("✓")} screen cleared`);
+    }
+    if (sub === "rm" || sub === "remove" || sub === "del") {
+        if (!rest.length)
+            return ui.print(C.faint("  usage: ctx rm <id>"));
+        for (const id of rest)
+            ui.print(store.remove(id) ? `  ${C.green("✓")} ${id} is off the screen` : C.red(`  ✗ no item ${id}`));
+        return;
+    }
+    if (sub === "note") {
+        const [id, ...words] = rest;
+        if (!id || !words.length)
+            return ui.print(C.faint("  usage: ctx note <id> <what everyone should know about it>"));
+        const n = store.note(id, words.join(" "), "you");
+        return ui.print("error" in n ? C.red(`  ✗ ${n.error}`) : `  📌 pinned on ${id}`);
+    }
+    const id = sub === "show" || sub === "cat" ? rest[0] : sub;
+    const it = id ? store.get(id) : undefined;
+    if (!it)
+        return ui.print(C.red(`  ✗ no item ${id ?? ""}`) + C.faint(" — `ctx` lists them"));
+    ui.print(`\n  ${C.bold(it.id)} ${it.kind} ${q(it.title)} ${C.faint(`· ${sizeWord(it)} · ${fmtBytes(it.bytes)} · by ${it.added_by}`)}`);
+    if (it.summary)
+        ui.print(C.faint(`  ${it.summary}`));
+    if (it.sections.length)
+        ui.print(C.faint(`  sections: ${it.sections.slice(0, 8).map((s, k) => `${k + 1}. ${s.title} (${s.from}-${s.to})`).join(" · ")}${it.sections.length > 8 ? " …" : ""}`));
+    const text = store.textOf(it);
+    if (text === null)
+        ui.print(C.faint(`  file: ${store.pathOf(it)}`));
+    else {
+        const lines = text.split("\n");
+        for (const l of lines.slice(0, 30))
+            ui.print(C.faint("  │ ") + l.slice(0, 200));
+        if (lines.length > 30)
+            ui.print(C.faint(`  │ … ${lines.length - 30} more lines`));
+    }
+    for (const n of it.notes)
+        ui.print(`  📌 ${C.bold(n.by)} ${n.body}`);
+}
+// ---- one-shot runs: huddle join "<goal>" --with f --with g, and stdin -----------
+/** `--with a --with=b` → ["a", "b"], and the args without them. */
+export function takeWith(args) {
+    const files = [];
+    const rest = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--with" && i + 1 < args.length)
+            files.push(args[++i]);
+        else if (a.startsWith("--with="))
+            files.push(a.slice(7));
+        else
+            rest.push(a);
+    }
+    return { files, rest };
+}
+/** Piped stdin (`cat log.txt | huddle join "fix this"`). Waits briefly for a first chunk, so an idle pipe never hangs a run. */
+export function readPipedStdin(stdin = process.stdin, firstMs = 300) {
+    if (stdin.isTTY)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        let data = "";
+        let started = false;
+        const done = () => {
+            clearTimeout(idle);
+            stdin.off("data", onData);
+            stdin.off("end", done);
+            stdin.off("error", done);
+            stdin.pause();
+            resolve(data);
+        };
+        const onData = (c) => {
+            started = true;
+            data += c.toString();
+        };
+        const idle = setTimeout(() => !started && done(), firstMs);
+        stdin.on("data", onData);
+        stdin.once("end", done);
+        stdin.once("error", done);
+        stdin.resume();
+    });
+}
+/** Text from a pipe (`cat err.log | huddle add -`) as one item. True if it's on the screen. */
+export async function addPiped(store, text, ui, opts = {}) {
+    const p = store.prepareText(text, { source: "stdin", title: opts.title });
+    if ("ok" in p) {
+        ui.print(C.red(`  ✗ stdin: ${p.reason}`));
+        return false;
+    }
+    return report(await save(store, p, ui), ui, "piped in");
+}
+/** Put a one-shot run's --with files and stdin on the screen before planning. */
+export async function addForRun(dbFile, files, piped, print, cwd = process.cwd()) {
+    if (!files.length && !piped.trim())
+        return 0;
+    const db = new RoomDB(dbFile);
+    const ui = { print, yes: async () => true, db: async () => db, audience: () => ({ agents: [], companies: 0 }), interactive: false };
+    let failed = 0;
+    try {
+        const store = ContextStore.open(db);
+        if (piped.trim() && !(await addPiped(store, piped, ui)))
+            failed++;
+        failed += files.length ? await addPaths(files, ui, cwd) : 0;
+    }
+    finally {
+        db.close();
+    }
+    return failed;
+}
+// ---- a teammate's side (`huddle join <address> <CODE>`) ----------------------------
+/**
+ * `add <file>` / `ctx` typed by a teammate: text files go to the host's screen
+ * over the shared API (the body cap there is 256 KB); `ctx` lists the screen.
+ */
+export async function remoteScreen(request, line, say) {
+    const [cmd] = line.split(/\s+/);
+    if (cmd === "ctx" || cmd === "context") {
+        const r = await request("GET", "/context");
+        if (r.status !== 200)
+            return say(C.red(`  ✗ ${r.body?.error ?? "couldn't read the screen"}`));
+        const items = r.body.items ?? [];
+        if (!items.length)
+            return say(C.faint("  nothing on the shared screen yet — `add <file>` to put a text file up"));
+        for (const i of items) {
+            say(`  ${C.bold(String(i.id).padEnd(6))} ${String(i.kind).padEnd(5)} ${q(String(i.title))} ${C.faint(`· ${i.size} · by ${i.added_by}`)}`);
+            for (const n of (i.notes ?? []).slice(-2))
+                say(`         📌 ${n}`);
+        }
+        return;
+    }
+    for (const f of splitPathTokens(line.slice(cmd.length))) {
+        let text;
+        try {
+            const buf = fs.readFileSync(f);
+            if (buf.length > 200 * 1024) {
+                say(C.red(`  ✗ ${path.basename(f)} is ${fmtBytes(buf.length)} — teammates can send text up to 200 KB; ask the host to add it`));
+                continue;
+            }
+            if (!looksTextBuf(buf)) {
+                say(C.red(`  ✗ ${path.basename(f)} isn't text — screenshots and PDFs go up from the host's machine`));
+                continue;
+            }
+            text = buf.toString("utf8");
+        }
+        catch (e) {
+            say(C.red(`  ✗ ${e?.code === "ENOENT" ? "no such file: " + f : e?.code === "EACCES" ? "permission denied: " + f : String(e?.message ?? e)}`));
+            continue;
+        }
+        // Secrets never leave this machine: redacted here, before the send.
+        const red = redactSecrets(text);
+        if (red.count)
+            say(C.yellow(`  ⚠ redacted ${red.count} likely secret${red.count > 1 ? "s" : ""} in ${path.basename(f)} before sending`));
+        const r = await request("POST", "/context/add", { text: red.text, title: path.basename(f) });
+        say(r.status === 200 ? `  📎 ${r.body.duplicate ? "already on the screen" : "on the screen"}: ${r.body.id} ${q(path.basename(f))}` : C.red(`  ✗ ${r.body?.error ?? "not added"}`));
+    }
+}
+//# sourceMappingURL=paste.js.map