huddle-cli 0.1.0 → 0.1.1

package/dist/room/contract.js

@@ -0,0 +1,132 @@
+// The CONTRACT: the exact cross-task names every task codes to — files and who
+// owns them, exported functions with signatures, data shapes, CLI flags,
+// routes, error strings. The design council ratifies it before work starts;
+// agents amend it mid-task (huddle_amend_contract) instead of inventing a name
+// a teammate depends on. Found live: two agents built the same app with
+// different names for the same thing, and the mismatch only surfaced at merge.
+//
+// Stored as Room events (contract.set / contract.amended), scoped to the
+// current session, so no schema change and `huddle story` replays it for free.
+import crypto from "node:crypto";
+/** The contract's text is capped: it rides in every task's launch prompt. */
+export const CONTRACT_CAP = 3000;
+/** Cap at a line break, so no name is cut in half (a half name is worse than none). */
+export function capContract(text, cap = CONTRACT_CAP) {
+    const t = text.trim();
+    if (t.length <= cap)
+        return t;
+    const cut = t.slice(0, cap - 12);
+    const nl = cut.lastIndexOf("\n");
+    return (nl > cap / 2 ? cut.slice(0, nl) : cut.replace(/\s+\S*$/, "")) + "\n…(capped)";
+}
+const sessionId = (db) => db.currentSession()?.id ?? null;
+function parse(p) {
+    try {
+        return JSON.parse(p || "{}");
+    }
+    catch {
+        return {};
+    }
+}
+/** The current session's contract with its amendments, or null when none was set. */
+export function getContract(db) {
+    const sid = sessionId(db);
+    const evs = db.eventsOfType(["contract.set", "contract.amended"], 0, 2000).map((e) => ({ type: e.type, ts: e.ts, p: parse(e.payload) }));
+    const sets = evs.filter((e) => e.type === "contract.set" && (e.p.session ?? null) === sid);
+    const base = sets[sets.length - 1];
+    if (!base)
+        return null;
+    // Amendments name the contract they amend, so a same-millisecond tie can't misorder them.
+    const amendments = evs
+        .filter((e) => e.type === "contract.amended" && e.p.base === base.p.id)
+        .map((e) => ({ section: String(e.p.section ?? ""), change: String(e.p.change ?? ""), why: String(e.p.why ?? ""), by: String(e.p.by ?? ""), version: Number(e.p.version) || 0, ts: e.ts }))
+        .sort((a, b) => a.version - b.version);
+    return {
+        text: String(base.p.text ?? ""),
+        version: amendments.length ? amendments[amendments.length - 1].version : typeof base.p.version === "number" ? base.p.version : 1,
+        by: base.p.by ?? null,
+        amendments,
+    };
+}
+/** Set (or replace) this session's contract: version 1, no amendments. */
+export function setContract(db, text, by) {
+    const t = capContract(text);
+    db.publish("contract.set", { agent_id: by, payload: { id: crypto.randomUUID(), session: sessionId(db), text: t, by, version: t ? 1 : 0 } });
+}
+/**
+ * Amend the contract: bumps its version and publishes "contract.amended".
+ * With no contract yet (a small goal skips the council), it starts an empty
+ * one, so agents can still agree names mid-task.
+ */
+export function amendContract(db, a) {
+    if (!getContract(db))
+        setContract(db, "", null);
+    const c = getContract(db);
+    const section = String(a.section ?? "").trim().slice(0, 200);
+    const change = String(a.change ?? "").trim().slice(0, 1500);
+    // A retried tool call is the same amendment, not a new version (and not a second broadcast).
+    const last = c.amendments[c.amendments.length - 1];
+    if (last && last.by === a.by && last.section === section && last.change === change)
+        return { version: last.version, duplicate: true };
+    const sets = db.eventsOfType(["contract.set"], 0, 2000).map((e) => parse(e.payload)).filter((p) => (p.session ?? null) === sessionId(db));
+    const version = c.version + 1;
+    db.publish("contract.amended", {
+        agent_id: a.by,
+        payload: { base: sets[sets.length - 1].id, version, section, change, why: String(a.why ?? "").trim().slice(0, 500), by: a.by },
+    });
+    return { version };
+}
+/** The contract as one prompt section for a task's launch; "" when there is none. */
+export function contractBrief(db) {
+    const c = getContract(db);
+    if (!c || (!c.text && !c.amendments.length))
+        return "";
+    const text = capContract(c.text);
+    const am = c.amendments.slice(-8).map((x) => `- v${x.version} by ${x.by}: ${x.section}: ${x.change}${x.why ? ` (${x.why})` : ""}`);
+    return [
+        // Not "see HUDDLE_CONTRACT.md": its commit can fail, and it never carries amendments.
+        `CONTRACT v${c.version} — the exact names every task codes to (huddle_contract shows the latest):`,
+        ...(text ? [text] : []),
+        ...(am.length ? ["Amendments:", ...am] : []),
+        "Use these exact names. Never invent a name another task depends on that isn't here: call huddle_amend_contract(section, change, why) first — it tells every teammate.",
+        "It never overrides the goal: where they differ on an exact output, message or format, the goal wins (amend this).",
+    ].join("\n");
+}
+/** The contract as a file for the repo root, so every worktree has it. */
+export function contractFile(text, by, members) {
+    return `# HUDDLE CONTRACT
+
+The exact cross-task names every task codes to, ratified by the design council (${members.join(", ")})${by ? `, written by ${by}` : ""}.
+To change a name, call huddle_amend_contract — don't edit this file. huddle_contract shows the latest version with amendments.
+
+${text.trim()}
+`;
+}
+const NOT_NAMES = new Set(["function", "const", "export", "import", "return", "string", "number", "boolean", "null", "undefined", "void", "async", "await", "interface", "type", "class", "true", "false", "Promise", "Array", "Record", "Object", "JSON", "HUDDLE_CONTRACT"]);
+/**
+ * The code names a contract fixes (for the radar's drift check): backticked
+ * identifiers, camelCase / snake_case / PascalCase-with-a-hump words, and
+ * anything called like `name(`. Plain English words are left out — a false
+ * "did you mean" sends an agent renaming code that works.
+ */
+export function contractNames(c) {
+    if (!c)
+        return [];
+    const text = [c.text, ...c.amendments.map((a) => a.change)].join("\n");
+    const out = new Set();
+    const add = (n) => {
+        if (n.length >= 3 && !NOT_NAMES.has(n) && /^[A-Za-z_$][\w$]*$/.test(n))
+            out.add(n);
+    };
+    for (const m of text.matchAll(/`([^`\n]{1,200})`/g))
+        for (const w of m[1].match(/[A-Za-z_$][\w$]*/g) ?? [])
+            if (/[a-z][A-Z]|_|^[A-Z][a-z]+[A-Z]/.test(w) || m[1].trim() === w)
+                add(w);
+    for (const m of text.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g))
+        add(m[1]);
+    for (const w of text.match(/\b[A-Za-z_$][\w$]*\b/g) ?? [])
+        if (/[a-z][A-Z]|[a-z]_[a-z]|^[A-Z][a-z]+[A-Z]/.test(w))
+            add(w);
+    return [...out].slice(0, 300);
+}
+//# sourceMappingURL=contract.js.map

package/dist/room/db.js

@@ -4,6 +4,8 @@
 // (sqlite.ts falls back to Node's built-in node:sqlite when the addon is missing.)
 import { openDatabase } from "./sqlite.js";
 import crypto from "node:crypto";
+import nodePath from "node:path";
+import { rememberLesson } from "./lessons.js";
 import { nanoid } from "nanoid";
 const SCHEMA = /* sql */ `
 CREATE TABLE IF NOT EXISTS session (
@@ -103,7 +105,16 @@ CREATE TABLE IF NOT EXISTS message (
   reply_to TEXT,
   task_id TEXT,
   created_at INTEGER NOT NULL,
-  read_at INTEGER
+  read_at INTEGER,
+  -- How it reached the recipient: piggyback | hook | inbox | ask | reply | prompt | cleared.
+  delivered_how TEXT
+);
+
+-- Every huddle_done, so evals can tell mail read mid-task from mail read at the end.
+CREATE TABLE IF NOT EXISTS done_log (
+  agent_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  ts INTEGER NOT NULL
 );
 
 -- What a merged task hands its dependents: summary, files, exported signatures, notes.
@@ -128,13 +139,15 @@ CREATE INDEX IF NOT EXISTS idx_event_ts ON event(ts);
  * directory holding the other.
  */
 export function pathsOverlap(a, b) {
-    const norm = (p) => p.split("::")[0].trim().replace(/^\.\//, "").replace(/\/+$/, "");
+    const norm = (p) => p.split("::")[0].trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
     const x = norm(a);
     const y = norm(b);
     if (!x || !y)
         return false;
     return x === y || x.startsWith(y + "/") || y.startsWith(x + "/");
 }
+/** A declared path with forward slashes ("src\\a.ts" → "src/a.ts"). */
+const slashed = (p) => String(p).replace(/\\/g, "/");
 const sha = (s) => crypto.createHash("sha256").update(s).digest("hex");
 /** Human-typable one-time code: 4-4-4 from an unambiguous alphabet. */
 function inviteCode() {
@@ -144,10 +157,12 @@ function inviteCode() {
     return `${s.slice(0, 4)}-${s.slice(4, 8)}-${s.slice(8, 12)}`;
 }
 export class RoomDB {
+    file;
     db;
     listeners = new Set();
-    constructor(path) {
-        this.db = openDatabase(path);
+    constructor(file) {
+        this.file = file;
+        this.db = openDatabase(file);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
         this.db.exec(SCHEMA);
@@ -156,6 +171,7 @@ export class RoomDB {
             "ALTER TABLE invite ADD COLUMN github TEXT",
             "ALTER TABLE member ADD COLUMN github TEXT",
             "ALTER TABLE task ADD COLUMN files TEXT NOT NULL DEFAULT '[]'",
+            "ALTER TABLE message ADD COLUMN delivered_how TEXT",
         ]) {
             try {
                 this.db.exec(sql);
@@ -165,6 +181,14 @@ export class RoomDB {
             }
         }
     }
+    /** Where the db file is (the shared screen keeps its files next to it). */
+    get path() {
+        return this.file;
+    }
+    /** The raw connection, for Room modules that keep their own tables (context.ts). */
+    get sql() {
+        return this.db;
+    }
     /** Subscribe to every event written to the Room (drives WS fan-out). */
     onEvent(fn) {
         this.listeners.add(fn);
@@ -197,7 +221,8 @@ export class RoomDB {
     }
     currentSession() {
         return this.db
-            .prepare("SELECT * FROM session WHERE status='open' ORDER BY created_at DESC LIMIT 1")
+            // rowid breaks a same-millisecond tie: the session created last is current.
+            .prepare("SELECT * FROM session WHERE status='open' ORDER BY created_at DESC, rowid DESC LIMIT 1")
             .get();
     }
     // ---- Agents -------------------------------------------------------------
@@ -286,7 +311,7 @@ export class RoomDB {
         this.db.exec("DELETE FROM task; DELETE FROM plan; DELETE FROM file_claim; UPDATE agent SET status='offline';");
         // Handoffs are keyed by this board's task ids; unread messages were about the old goal.
         this.db.prepare("DELETE FROM handoff").run();
-        this.db.prepare("UPDATE message SET read_at=? WHERE read_at IS NULL").run(Date.now());
+        this.db.prepare("UPDATE message SET read_at=?, delivered_how='cleared' WHERE read_at IS NULL").run(Date.now());
         this.emit("board.cleared", {});
     }
     /** Put a claimed task back on the board (a teammate declined or left). */
@@ -334,6 +359,8 @@ export class RoomDB {
     }
     // ---- Plans & overlap ----------------------------------------------------
     announcePlan(p) {
+        // An agent on Windows may say src\a.ts; leases are kept as src/a.ts.
+        p = { ...p, touches: p.touches.map(slashed) };
         const conflicts = this.checkOverlap(p.touches, p.agent_id);
         const plan = {
             id: nanoid(8),
@@ -361,6 +388,7 @@ export class RoomDB {
     }
     /** Which touched paths/symbols are already held by *someone else*. */
     checkOverlap(touches, byAgent) {
+        touches = touches.map(slashed);
         if (!touches.length)
             return [];
         const now = Date.now();
@@ -376,6 +404,21 @@ export class RoomDB {
         const leased = this.db.prepare("SELECT path FROM file_claim WHERE expires_at > ?").all(Date.now());
         return [...active.flatMap((r) => JSON.parse(r.files ?? "[]")), ...leased.map((r) => r.path)];
     }
+    /** A split part takes these files: they leave the parent's file list and the parent's leases on them end. */
+    handOverFiles(parentId, files) {
+        const t = this.getTask(parentId);
+        if (!t)
+            return;
+        // A parent entry that is a whole directory around a part's file stays: it can't be split finer.
+        const norm = (p) => p.split("::")[0].trim().replace(/^\.\//, "").replace(/\/+$/, "");
+        const handed = (f) => files.some((p) => pathsOverlap(f, p) && !norm(p).startsWith(norm(f) + "/"));
+        const keep = JSON.parse(t.files ?? "[]").filter((f) => !handed(f));
+        this.db.prepare("UPDATE task SET files=?, updated_at=? WHERE id=?").run(JSON.stringify(keep), Date.now(), parentId);
+        const leases = this.db.prepare("SELECT path FROM file_claim WHERE task_id=?").all(parentId);
+        for (const l of leases)
+            if (handed(l.path))
+                this.db.prepare("DELETE FROM file_claim WHERE path=? AND task_id=?").run(l.path, parentId);
+    }
     releaseClaims(agentId) {
         this.db.prepare("DELETE FROM file_claim WHERE held_by=?").run(agentId);
     }
@@ -514,26 +557,42 @@ export class RoomDB {
     getMessage(id) {
         return this.db.prepare("SELECT * FROM message WHERE id=?").get(id);
     }
-    /** Unread messages for `agent`, oldest first. Reading marks them read unless `peek`. */
+    /**
+     * Unread messages for `agent`, oldest first (at most `limit`). Reading marks
+     * them read, recording `how` they were delivered, unless `peek`.
+     */
     inbox(agent, opts = {}) {
         const rows = this.db
-            .prepare("SELECT * FROM message WHERE to_agent=? AND read_at IS NULL ORDER BY created_at, rowid")
-            .all(agent);
-        if (!opts.peek && rows.length) {
-            const mark = this.db.prepare("UPDATE message SET read_at=? WHERE id=?");
-            const now = Date.now();
+            .prepare("SELECT * FROM message WHERE to_agent=? AND read_at IS NULL ORDER BY created_at, rowid LIMIT ?")
+            .all(agent, opts.limit ?? -1);
+        if (!opts.peek)
             for (const r of rows)
-                mark.run(now, r.id);
-        }
+                this.markRead(r.id, opts.how ?? "inbox");
         return rows;
     }
+    /** Messages `agent` already got in a tool result or hook since `sinceTs`, newest last. */
+    recentlyDelivered(agent, sinceTs, limit = 3) {
+        const rows = this.db
+            .prepare(`SELECT * FROM message WHERE to_agent=? AND read_at >= ? AND delivered_how IN ('piggyback','hook')
+         ORDER BY read_at DESC, rowid DESC LIMIT ?`)
+            .all(agent, sinceTs, limit);
+        return rows.reverse();
+    }
+    /** Every message since `sinceTs` with when/how it was read — the input to delivery metrics. */
+    messagesSince(sinceTs = 0) {
+        return this.db.prepare("SELECT * FROM message WHERE created_at >= ? ORDER BY created_at, rowid").all(sinceTs);
+    }
+    /** When each agent called huddle_done (oldest first). */
+    doneTimes(sinceTs = 0) {
+        return this.db.prepare("SELECT * FROM done_log WHERE ts >= ? ORDER BY ts, rowid").all(sinceTs);
+    }
     /** Unread count and senders — the piggyback nudge on every tool result. */
     unread(agent) {
         const rows = this.db.prepare("SELECT from_agent FROM message WHERE to_agent=? AND read_at IS NULL").all(agent);
         return { count: rows.length, from: [...new Set(rows.map((r) => r.from_agent))] };
     }
-    markRead(id) {
-        this.db.prepare("UPDATE message SET read_at=? WHERE id=? AND read_at IS NULL").run(Date.now(), id);
+    markRead(id, how = "inbox") {
+        this.db.prepare("UPDATE message SET read_at=?, delivered_how=? WHERE id=? AND read_at IS NULL").run(Date.now(), how, id);
     }
     /**
      * The reply to a routed question: an explicit reply_to, or — since models
@@ -549,6 +608,7 @@ export class RoomDB {
     // ---- Handoffs -------------------------------------------------------------
     /** huddle_done's summary, kept for the handoff the merge will write. */
     noteDone(taskId, agentId, summary) {
+        this.db.prepare("INSERT INTO done_log (agent_id, task_id, ts) VALUES (?, ?, ?)").run(agentId, taskId, Date.now());
         this.db
             .prepare(`INSERT INTO handoff (task_id, agent_id, title, summary, created_at) VALUES (?, ?, COALESCE((SELECT title FROM task WHERE id=?), ''), ?, ?)
          ON CONFLICT(task_id) DO UPDATE SET summary=excluded.summary, agent_id=excluded.agent_id`)
@@ -593,6 +653,9 @@ export class RoomDB {
             .prepare("INSERT INTO memory (id,kind,body,why,author,created_at) VALUES (@id,@kind,@body,@why,@author,@created_at)")
             .run(mem);
         this.emit("memory.added", { agent_id: m.author, payload: mem });
+        // A lesson outlives the room: <repo>/.huddle/huddle.db → that repo's lessons.
+        if (m.kind === "lesson")
+            rememberLesson({ body: m.body, why: m.why, author: m.author, root: nodePath.basename(nodePath.dirname(this.file)) === ".huddle" ? nodePath.dirname(nodePath.dirname(this.file)) : null });
         return mem;
     }
     recall(query) {

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

@@ -22,7 +22,7 @@ export async function githubKeys(user) {
         const r = await fetch(`https://github.com/${encodeURIComponent(user)}.keys`, { signal: AbortSignal.timeout(8000) });
         if (!r.ok)
             return [];
-        const keys = (await r.text()).split("\n").filter((l) => l.startsWith("ssh-")).map(bare);
+        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;
     }
@@ -77,7 +77,7 @@ export async function signAs(user, 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("\n")[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 {