huddle-cli 0.0.0-stage → 0.1.1

package/dist/room/followup.js

@@ -0,0 +1,233 @@
+// Notes that need an answer: a buddy check's notes and a radar finding, sent
+// to an agent while it works on a task.
+//
+// Found live (capstone round 4): codex's buddy check told cursor at 50% that
+// isBlankRecord drops real CSV records like ",,,". Cursor finished without a
+// word about it, and QA round 2 filed exactly that bug a whole fix cycle
+// later. Now each such note stays "open" for the author's task until it is
+// answered:
+//
+//   replied   the author sent a message with reply_to = the note's id
+//             ("won't fix: <why>" is an answer too)
+//   fixed     a file the note names (or, if it names none, any file of the
+//             author's work in progress) changed after the note was delivered
+//
+// huddle_done with notes still open is refused ONCE, with the list
+// (src/room/server.ts). The second huddle_done always goes through, so this
+// can never deadlock a task. What happened to each note (addressed or
+// ignored) is published as note.closed, for `huddle story`, the live view and
+// the evals. Built on Room events and the message table; no new tables.
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+/** One-time refusal of huddle_done per task: the second one always goes through. */
+export const REFUSE_ONCE = "done.refused";
+const json = (s) => {
+    try {
+        return JSON.parse(s || "{}");
+    }
+    catch {
+        return {};
+    }
+};
+/** Files the author's worktree has changed (tracked edits and new files), relative paths. */
+function changedFiles(worktree) {
+    try {
+        const r = spawnSync("git", ["-c", "core.quotePath=false", "status", "--porcelain", "-z", "-uall"], { cwd: worktree, encoding: "utf8" });
+        if (r.status !== 0)
+            return [];
+        const out = [];
+        const parts = String(r.stdout ?? "").split("\0");
+        for (let i = 0; i < parts.length; i++) {
+            const p = parts[i];
+            if (p.length < 4)
+                continue;
+            out.push(p.slice(3));
+            if (p[0] === "R" || p[0] === "C")
+                i++; // a rename's source path follows
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function trackedFiles(worktree) {
+    try {
+        const r = spawnSync("git", ["-c", "core.quotePath=false", "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: worktree, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+        return r.status === 0 ? String(r.stdout ?? "").split("\0").filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The files a note names: a path with a directory ("src/csv.js", even one
+ * not written yet — "test/books.test.js doesn't exist yet" is answered by
+ * creating it), or a bare name that is a file in the worktree ("csv.js").
+ * "import.meta.url" and "e.g." are not files.
+ */
+export function namedFiles(body, worktree) {
+    const found = new Set();
+    const re = /(?:^|[\s(`'"“[])((?:\.\/)?(?:[\w@.-]+\/)*[\w@-][\w@.-]*\.[A-Za-z][A-Za-z0-9]{0,7})(?=$|[\s)`'"”,:;!?\]]|\.(?:\s|$))/g;
+    let all = null;
+    for (const m of String(body).matchAll(re)) {
+        const f = m[1].replace(/^\.\//, "");
+        if (f.split("/").includes("..") || path.isAbsolute(f))
+            continue;
+        if (f.includes("/")) {
+            found.add(f);
+            continue;
+        }
+        all ??= trackedFiles(worktree);
+        for (const t of all)
+            if (t === f || t.endsWith("/" + f))
+                found.add(t);
+    }
+    return [...found].slice(0, 12);
+}
+/** Start tracking `msg` (already in the author's inbox) as a note the author must answer. */
+export function trackNote(db, msg, o) {
+    if (!msg.task_id)
+        return;
+    try {
+        db.publish("note.open", {
+            task_id: msg.task_id,
+            agent_id: msg.to_agent,
+            payload: { id: msg.id, to: msg.to_agent, by: o.by, kind: o.kind, files: namedFiles(msg.body, o.worktree), worktree: o.worktree, ...(o.key ? { key: o.key } : {}) },
+        });
+    }
+    catch {
+        /* a closed db never breaks a run */
+    }
+}
+/** Every note tracked for `taskId`, oldest first. */
+export function notesFor(db, taskId) {
+    const out = [];
+    for (const e of db.eventsOfType(["note.open"], 0, 1000)) {
+        if (e.task_id !== taskId)
+            continue;
+        const p = json(e.payload);
+        const m = db.getMessage(String(p.id ?? ""));
+        if (!m)
+            continue;
+        out.push({ id: m.id, to: m.to_agent, task: taskId, by: String(p.by ?? "huddle"), kind: p.kind === "radar" ? "radar" : "buddy", files: Array.isArray(p.files) ? p.files.map(String) : [], worktree: String(p.worktree ?? ""), body: m.body, at: m.created_at });
+    }
+    return out;
+}
+/** Notes already closed for `taskId`: id -> how. */
+export function closedNotes(db, taskId) {
+    const out = new Map();
+    for (const e of db.eventsOfType(["note.closed"], 0, 1000)) {
+        if (e.task_id !== taskId)
+            continue;
+        const p = json(e.payload);
+        if (p.id)
+            out.set(String(p.id), p.how);
+    }
+    return out;
+}
+/** Has the author answered this note? replied / fixed, or null (still open). */
+export function noteAnswer(db, n) {
+    // A change to a file the note names counts first: found live (capstone round 5), authors
+    // who fixed a note AND replied "Fixed both" were all tallied "replied" (0 fixed).
+    const delivered = db.getMessage(n.id)?.read_at;
+    const changedSince = (files) => !!delivered &&
+        !!n.worktree &&
+        files.some((f) => {
+            try {
+                return fs.statSync(path.join(n.worktree, f)).mtimeMs > delivered;
+            }
+            catch {
+                return false; // not written (yet): not a fix
+            }
+        });
+    if (n.files.length && changedSince(n.files))
+        return "fixed";
+    const msgs = db.messagesSince(n.at);
+    if (msgs.some((m) => m.reply_to === n.id && m.from_agent === n.to))
+        return "replied";
+    // A note that names no file: any change to the author's work after it was seen.
+    if (!n.files.length && n.worktree && changedSince(changedFiles(n.worktree)))
+        return "fixed";
+    return null; // never seen, or seen and not acted on
+}
+/**
+ * The notes on `taskId` still waiting for the author's answer. A radar
+ * re-alert repeats a finding: notes with the same text count once, and an
+ * answer to any copy answers them all.
+ */
+export function openNotes(db, taskId) {
+    const closed = closedNotes(db, taskId);
+    const notes = notesFor(db, taskId).filter((n) => !closed.has(n.id));
+    const answered = new Set(notes.filter((n) => noteAnswer(db, n)).map((n) => n.body));
+    const seen = new Set();
+    return notes.filter((n) => {
+        if (answered.has(n.body) || seen.has(n.body))
+            return false;
+        seen.add(n.body);
+        return true;
+    });
+}
+/**
+ * The task is finishing: record how each of its notes ended — replied, fixed,
+ * or ignored. Idempotent (a closed note stays closed). Returns this call's tally.
+ */
+export function closeNotes(db, taskId) {
+    const closed = closedNotes(db, taskId);
+    const notes = notesFor(db, taskId).filter((n) => !closed.has(n.id));
+    const how = new Map(notes.map((n) => [n.id, noteAnswer(db, n)]));
+    // One answer covers every copy of the same text (radar re-alerts).
+    const byBody = new Map();
+    for (const n of notes) {
+        const h = how.get(n.id);
+        if (h && !byBody.has(n.body))
+            byBody.set(n.body, h);
+    }
+    const out = { addressed: [], ignored: [] };
+    for (const n of notes) {
+        const h = how.get(n.id) ?? byBody.get(n.body) ?? "ignored";
+        (h === "ignored" ? out.ignored : out.addressed).push(n);
+        try {
+            db.publish("note.closed", { task_id: taskId, agent_id: n.to, payload: { id: n.id, by: n.by, to: n.to, kind: n.kind, how: h, body: n.body.slice(0, 300) } });
+        }
+        catch {
+            /* closed db */
+        }
+    }
+    return out;
+}
+/**
+ * The radar no longer sees finding `key` (src/orchestrator/radar.ts): every
+ * open note about it is answered — fixed, by whichever side changed its code.
+ */
+export function resolveNotes(db, key) {
+    let n = 0;
+    for (const e of db.eventsOfType(["note.open"], 0, 1000)) {
+        const p = json(e.payload);
+        if (p.key !== key || !e.task_id || closedNotes(db, e.task_id).has(String(p.id)))
+            continue;
+        const m = db.getMessage(String(p.id));
+        db.publish("note.closed", { task_id: e.task_id, agent_id: p.to ?? e.agent_id, payload: { id: p.id, by: p.by, to: p.to, kind: p.kind, how: "fixed", body: String(m?.body ?? "").slice(0, 300) } });
+        n++;
+    }
+    return n;
+}
+/** Was this task's huddle_done already refused once? */
+export function refusedOnce(db, taskId) {
+    return db.eventsOfType([REFUSE_ONCE], 0, 1000).some((e) => e.task_id === taskId);
+}
+/** What the author is told when huddle_done is refused: each open note, and how to answer it. */
+export function refusal(notes) {
+    const who = (n) => (n.kind === "radar" ? "huddle" : n.by);
+    const first = notes[0];
+    return {
+        ok: false,
+        refused: true,
+        open_notes: notes.map((n) => ({ id: n.id, from: who(n), kind: n.kind, text: n.body.length > 600 ? n.body.slice(0, 600) + "…" : n.body })),
+        note: `NOT done yet: ${notes.length} teammate note${notes.length > 1 ? "s" : ""} on this task ${notes.length > 1 ? "have" : "has"} no answer. ` +
+            `Address each: fix it, or reply huddle_send(to='${who(first)}', reply_to='${first.id}', message="won't fix: <why>"). ` +
+            `Then call huddle_done again (that one always goes through; an unanswered note is recorded as ignored).`,
+    };
+}
+//# sourceMappingURL=followup.js.map

package/dist/room/identity.js

@@ -0,0 +1,122 @@
+// Identity = your GitHub account, proven with the SSH key you already use for git.
+//
+// GitHub publishes everyone's public SSH keys at https://github.com/<user>.keys.
+// So when a room invites @harsh, whoever joins must sign a one-time challenge
+// with a private key whose public half is on Harsh's GitHub. Huddle verifies
+// with `ssh-keygen -Y verify`. No passwords, no OAuth app, no credentials held —
+// the private key never leaves the joiner's machine.
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const NAMESPACE = "huddle-join";
+const cache = new Map();
+/** "ssh-ed25519 AAAA… comment" → "ssh-ed25519 AAAA…" */
+const bare = (line) => line.trim().split(/\s+/).slice(0, 2).join(" ");
+export async function githubKeys(user) {
+    const hit = cache.get(user.toLowerCase());
+    if (hit && Date.now() - hit.at < 10 * 60_000)
+        return hit.keys;
+    try {
+        const r = await fetch(`https://github.com/${encodeURIComponent(user)}.keys`, { signal: AbortSignal.timeout(8000) });
+        if (!r.ok)
+            return [];
+        const keys = (await r.text()).split(/\r?\n/).filter((l) => l.startsWith("ssh-")).map(bare);
+        cache.set(user.toLowerCase(), { at: Date.now(), keys });
+        return keys;
+    }
+    catch {
+        return [];
+    }
+}
+/** Your GitHub login, from the gh CLI or git config. */
+export function githubUser() {
+    const gh = spawnSync("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8", timeout: 8000 });
+    if (gh.status === 0 && gh.stdout.trim())
+        return gh.stdout.trim();
+    const g = spawnSync("git", ["config", "github.user"], { encoding: "utf8" });
+    return g.stdout?.trim() || null;
+}
+function localKeyPairs() {
+    const dir = path.join(os.homedir(), ".ssh");
+    let files = [];
+    try {
+        files = fs.readdirSync(dir).filter((f) => f.endsWith(".pub"));
+    }
+    catch {
+        return [];
+    }
+    return files
+        .map((f) => {
+        const pub = path.join(dir, f);
+        const priv = pub.slice(0, -4);
+        try {
+            return { priv, pub, key: bare(fs.readFileSync(pub, "utf8")) };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((x) => !!x && fs.existsSync(x.priv));
+}
+/**
+ * Sign a challenge as GitHub user `user`: pick the local key that's on their
+ * GitHub, sign with ssh-keygen (it asks for your passphrase if the key has one).
+ */
+export async function signAs(user, nonce) {
+    const published = new Set(await githubKeys(user));
+    if (!published.size)
+        return { ok: false, reason: `couldn't read github.com/${user}.keys (no keys, or no network)` };
+    const mine = localKeyPairs().find((k) => published.has(k.key));
+    if (!mine)
+        return { ok: false, reason: `none of your ~/.ssh keys are on github.com/${user} — are you ${user}?` };
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "huddle-sign-"));
+    const msg = path.join(tmp, "challenge");
+    fs.writeFileSync(msg, nonce);
+    const r = spawnSync("ssh-keygen", ["-Y", "sign", "-q", "-f", mine.priv, "-n", NAMESPACE, msg], { stdio: ["inherit", "pipe", "pipe"] });
+    try {
+        if (r.status !== 0)
+            return { ok: false, reason: `ssh-keygen couldn't sign: ${String(r.stderr).trim().split(/\r?\n/)[0]}` };
+        return { ok: true, key: mine.key, sig: fs.readFileSync(msg + ".sig", "utf8") };
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+/** Is `sig` a signature of `nonce` by a key that's on github.com/<user>.keys? */
+export async function verifyAs(user, nonce, key, sig) {
+    if (!(await githubKeys(user)).includes(bare(key)))
+        return false;
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "huddle-verify-"));
+    try {
+        const allowed = path.join(tmp, "allowed");
+        const sigFile = path.join(tmp, "sig");
+        fs.writeFileSync(allowed, `${user} namespaces="${NAMESPACE}" ${bare(key)}\n`);
+        fs.writeFileSync(sigFile, sig);
+        const r = spawnSync("ssh-keygen", ["-Y", "verify", "-f", allowed, "-I", user, "-n", NAMESPACE, "-s", sigFile], {
+            input: nonce,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return r.status === 0;
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+export const newNonce = () => crypto.randomBytes(24).toString("hex");
+/** "github.com/owner/repo" → "owner/repo", when the remote is on GitHub. */
+export function githubRepo(canonical) {
+    const m = /^github\.com\/([^/]+\/[^/]+)$/.exec(canonical);
+    return m ? m[1] : null;
+}
+/** Can `user` push to owner/repo? true/false, or null if we can't tell (no gh). */
+export function isCollaborator(repo, user) {
+    const r = spawnSync("gh", ["api", `repos/${repo}/collaborators/${user}`, "--silent"], { encoding: "utf8", timeout: 10_000 });
+    if (r.error)
+        return null;
+    if (r.status === 0)
+        return true;
+    return /404|not a collaborator/i.test(`${r.stderr}${r.stdout}`) ? false : null;
+}
+//# sourceMappingURL=identity.js.map

package/dist/room/lessons.js

@@ -0,0 +1,275 @@
+// Lessons: what Huddle learned on this machine, carried from one run to the
+// next. A room's shared memory dies with its goal; a lesson outlives it —
+// "cursor's council turns time out", "agents collide on src/index.js: give
+// it one owner" — and goes into the next run's agent and planner prompts.
+//
+// Stored as an append-only log, ~/.huddle/lessons.jsonl (HUDDLE_HOME moves
+// it). Each line is one op — add, hit, use, forget, clear — so two runs
+// appending at once never lose each other's writes, and a torn or garbled
+// line is skipped instead of losing the file. HUDDLE_NO_LESSONS=1 turns the
+// whole thing off: nothing read, nothing learned.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { nanoid } from "nanoid";
+export const LESSON_MAX = 300;
+const EVIDENCE_MAX = 200;
+/** Compact the log past this many lines (uses pile up: one per lesson per launch). */
+const COMPACT_LINES = 2000;
+/** Opt-out, read at call time so a test can flip it. */
+export const lessonsOff = () => !!process.env.HUDDLE_NO_LESSONS;
+export function lessonsFile(home) {
+    return path.join(home ?? process.env.HUDDLE_HOME ?? path.join(os.homedir(), ".huddle"), "lessons.jsonl");
+}
+const cap = (s, n) => {
+    const t = s.replace(/\s+/g, " ").trim();
+    return t.length <= n ? t : t.slice(0, n - 1).replace(/\s+\S*$/, "") + "…";
+};
+/** Lowercase words, punctuation gone: what two phrasings of one lesson share. */
+export function normalize(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^\p{L}\p{N}\s/._#-]+/gu, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** Paths, ids, numbers: "src/index.js", "#12", "v2" — the words a lesson is ABOUT. */
+const specific = (w) => /[/._#\d]/.test(w);
+function words(text) {
+    return new Set(normalize(text).split(" ").filter((w) => w.length > 2 && !specific(w)));
+}
+function names(text) {
+    return [...new Set(normalize(text).split(" ").filter(specific))].sort().join(" ");
+}
+/**
+ * Near-identical: same words in another order, a word or two changed — but
+ * about the same things: "collide on src/index.js" never merges with
+ * "collide on README.md".
+ */
+export function similar(a, b) {
+    const na = normalize(a);
+    const nb = normalize(b);
+    if (na === nb)
+        return true;
+    if (names(a) !== names(b))
+        return false;
+    const wa = words(a);
+    const wb = words(b);
+    if (!wa.size || !wb.size)
+        return false;
+    let both = 0;
+    for (const w of wa)
+        if (wb.has(w))
+            both++;
+    return both / (wa.size + wb.size - both) >= 0.75;
+}
+function readOps(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const ops = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o && typeof o.op === "string")
+                ops.push(o);
+        }
+        catch {
+            /* a torn write or hand edit: skip the line, keep the rest */
+        }
+    }
+    return ops;
+}
+function reduce(ops) {
+    const byId = new Map();
+    for (const o of ops) {
+        if (o.op === "clear")
+            byId.clear();
+        else if (o.op === "add" && o.lesson?.id && typeof o.lesson.text === "string")
+            byId.set(o.lesson.id, { ...o.lesson, hits: Number(o.lesson.hits) || 1 });
+        else if (o.op === "hit") {
+            const l = byId.get(o.id);
+            if (l) {
+                l.hits++;
+                if (o.evidence)
+                    l.evidence = o.evidence;
+            }
+        }
+        else if (o.op === "use")
+            for (const id of o.ids ?? []) {
+                const l = byId.get(id);
+                if (l)
+                    l.last_used = Math.max(l.last_used ?? 0, o.ts);
+            }
+        else if (o.op === "forget")
+            byId.delete(o.id);
+    }
+    return [...byId.values()];
+}
+function append(file, ops) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // One write per call, O_APPEND: concurrent runs interleave whole lines.
+    fs.appendFileSync(file, ops.map((o) => JSON.stringify(o)).join("\n") + "\n");
+}
+/** Rewrite the log as one add per live lesson. Temp file + rename: a reader never sees half a file. */
+function compact(file) {
+    const live = reduce(readOps(file));
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, live.map((lesson) => JSON.stringify({ op: "add", lesson })).join("\n") + (live.length ? "\n" : ""));
+    fs.renameSync(tmp, file);
+}
+function maybeCompact(file) {
+    try {
+        const n = fs.readFileSync(file, "utf8").split("\n").length;
+        if (n > COMPACT_LINES)
+            compact(file);
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Every lesson, unsorted. */
+export function allLessons(home) {
+    return reduce(readOps(lessonsFile(home)));
+}
+/**
+ * Add a lesson, or — if one in the same scope says nearly the same thing —
+ * count it again (hits+1) and return that one. Returns null when lessons are
+ * off or the text is empty.
+ */
+export function addLesson(d, home) {
+    if (lessonsOff())
+        return null;
+    const text = cap(String(d.text ?? ""), LESSON_MAX);
+    if (!text || !validScope(d.scope))
+        return null;
+    const file = lessonsFile(home);
+    const evidence = cap(String(d.evidence ?? ""), EVIDENCE_MAX);
+    const same = reduce(readOps(file)).find((l) => l.scope === d.scope && similar(l.text, text));
+    if (same) {
+        append(file, [{ op: "hit", id: same.id, ts: Date.now(), ...(evidence ? { evidence } : {}) }]);
+        return { lesson: { ...same, hits: same.hits + 1, evidence: evidence || same.evidence }, added: false };
+    }
+    const lesson = { id: nanoid(8), text, scope: d.scope, source: cap(String(d.source ?? ""), 120), evidence, hits: 1, created: Date.now(), last_used: null };
+    append(file, [{ op: "add", lesson }]);
+    maybeCompact(file);
+    return { lesson, added: true };
+}
+export function validScope(s) {
+    return s === "all" || (typeof s === "string" && /^(agent|repo):[^\s]+$/.test(s));
+}
+/** The CLI id a worker runs: claude#2 learns what claude learned. */
+export const agentBase = (id) => id.split("#")[0].split("/").pop() ?? id;
+const keys = new Map();
+/**
+ * A repo's identity for lessons: its first commit, so every worktree and clone
+ * of one project shares them. A repo with no commits yet: its path.
+ */
+export function repoKey(dir) {
+    let real = dir;
+    try {
+        real = fs.realpathSync(dir);
+    }
+    catch {
+        /* keep as given */
+    }
+    const known = keys.get(real);
+    if (known)
+        return known;
+    const r = spawnSync("git", ["rev-list", "--max-parents=0", "HEAD"], { cwd: real, encoding: "utf8" });
+    const root = r.status === 0 ? (r.stdout ?? "").trim().split("\n").sort()[0] : "";
+    const key = (root || createHash("sha1").update(real).digest("hex")).slice(0, 12);
+    keys.set(real, key);
+    return key;
+}
+/**
+ * The lessons for one prompt: everything scoped "all", this repo's, and this
+ * agent's — or, with no agent (the planner, who assigns everyone), every
+ * agent's. Most-seen first, then most recent; at most `limit` and `maxChars`.
+ */
+export function lessonsFor(o = {}) {
+    if (lessonsOff())
+        return [];
+    const repo = o.repo ? `repo:${repoKey(o.repo)}` : null;
+    const agent = o.agentId ? `agent:${agentBase(o.agentId)}` : null;
+    const fits = (l) => l.scope === "all" || l.scope === repo || (agent ? l.scope === agent : l.scope.startsWith("agent:"));
+    const ranked = allLessons(o.home)
+        .filter(fits)
+        .sort((a, b) => b.hits - a.hits || Math.max(b.last_used ?? 0, b.created) - Math.max(a.last_used ?? 0, a.created));
+    const out = [];
+    let chars = 0;
+    for (const l of ranked) {
+        if (out.length >= (o.limit ?? 8))
+            break;
+        if (chars + l.text.length > (o.maxChars ?? 1200))
+            continue;
+        chars += l.text.length;
+        out.push(l);
+    }
+    return out;
+}
+/** Note that these lessons went into a prompt. */
+export function markUsed(ids, home) {
+    if (lessonsOff() || !ids.length)
+        return;
+    try {
+        append(lessonsFile(home), [{ op: "use", ids, ts: Date.now() }]);
+    }
+    catch {
+        /* a read-only home never breaks a run */
+    }
+}
+/**
+ * The prompt section, or "" when there's nothing to say. `dry`: don't count
+ * it as used (a --plan dry run).
+ */
+export function lessonsBrief(o = {}) {
+    let picked;
+    try {
+        picked = lessonsFor(o);
+    }
+    catch {
+        return ""; // a broken store never blocks a launch
+    }
+    if (!picked.length)
+        return "";
+    if (!o.dry)
+        markUsed(picked.map((l) => l.id), o.home);
+    const who = (l) => (!o.agentId && l.scope.startsWith("agent:") ? `(${l.scope.slice(6)}) ` : "");
+    return `LESSONS FROM EARLIER RUNS (what Huddle learned on this machine — follow them unless your task says otherwise):\n${picked.map((l) => `- ${who(l)}${l.text}`).join("\n")}\n\n`;
+}
+export function forgetLesson(id, home) {
+    if (!allLessons(home).some((l) => l.id === id))
+        return false;
+    append(lessonsFile(home), [{ op: "forget", id }]);
+    return true;
+}
+export function clearLessons(home) {
+    const n = allLessons(home).length;
+    const file = lessonsFile(home);
+    if (fs.existsSync(file))
+        fs.rmSync(file);
+    return n;
+}
+/** An agent's own huddle_remember(kind="lesson"): kept for the next runs in this repo. Never throws. */
+export function rememberLesson(o) {
+    if (lessonsOff())
+        return null;
+    try {
+        const text = o.why ? `${o.body} (${o.why})` : o.body;
+        return addLesson({ text, scope: o.root ? `repo:${repoKey(o.root)}` : "all", source: `agent:${o.author}`, evidence: `huddle_remember by ${o.author}` }, o.home)?.lesson ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=lessons.js.map