huddle-cli 0.0.0-stage → 0.1.1

package/dist/room/db.js

@@ -0,0 +1,680 @@
+// The Room's storage: one SQLite file (.huddle/huddle.db) that is the single
+// source of truth for the whole session. Synchronous better-sqlite3 is ideal
+// for a local single-writer daemon — fast, zero-setup, trivially inspectable.
+// (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 (
+  id TEXT PRIMARY KEY,
+  goal TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'open',
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent (
+  id TEXT PRIMARY KEY,
+  vendor TEXT NOT NULL,
+  model TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'worker',
+  worktree_path TEXT,
+  status TEXT NOT NULL DEFAULT 'idle',
+  budget_cents INTEGER NOT NULL DEFAULT 0,
+  spent_cents INTEGER NOT NULL DEFAULT 0,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS task (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  spec TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'backlog',
+  claimed_by TEXT,
+  progress_pct INTEGER NOT NULL DEFAULT 0,
+  depends_on TEXT NOT NULL DEFAULT '[]',
+  prefers TEXT NOT NULL DEFAULT '[]',
+  est_seconds INTEGER,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS plan (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  intent TEXT NOT NULL,
+  touches TEXT NOT NULL DEFAULT '[]',
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS memory (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  body TEXT NOT NULL,
+  why TEXT NOT NULL DEFAULT '',
+  author TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS file_claim (
+  path TEXT PRIMARY KEY,
+  held_by TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  expires_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS event (
+  id TEXT PRIMARY KEY,
+  task_id TEXT,
+  agent_id TEXT,
+  type TEXT NOT NULL,
+  payload TEXT NOT NULL DEFAULT '{}',
+  ts INTEGER NOT NULL
+);
+
+-- Multiplayer: people in the room, and one-time invites to get in.
+-- Tokens and invite codes are stored hashed, never in the clear.
+CREATE TABLE IF NOT EXISTS member (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'member',
+  token_hash TEXT NOT NULL UNIQUE,
+  joined_at INTEGER NOT NULL,
+  left_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS invite (
+  code_hash TEXT PRIMARY KEY,
+  role TEXT NOT NULL DEFAULT 'member',
+  for_name TEXT,
+  expires_at INTEGER NOT NULL,
+  used_by TEXT
+);
+
+-- Agent-to-agent messages (huddle_send / huddle_inbox / routed huddle_ask).
+-- kind: note | question | answer. Unread until the recipient reads its inbox.
+CREATE TABLE IF NOT EXISTS message (
+  id TEXT PRIMARY KEY,
+  from_agent TEXT NOT NULL,
+  to_agent TEXT NOT NULL,
+  body TEXT NOT NULL,
+  kind TEXT NOT NULL DEFAULT 'note',
+  reply_to TEXT,
+  task_id TEXT,
+  created_at INTEGER NOT NULL,
+  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.
+CREATE TABLE IF NOT EXISTS handoff (
+  task_id TEXT PRIMARY KEY,
+  agent_id TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  summary TEXT NOT NULL DEFAULT '',
+  files TEXT NOT NULL DEFAULT '[]',
+  symbols TEXT NOT NULL DEFAULT '[]',
+  notes TEXT NOT NULL DEFAULT '[]',
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_status ON task(status);
+CREATE INDEX IF NOT EXISTS idx_message_to ON message(to_agent, read_at);
+CREATE INDEX IF NOT EXISTS idx_event_ts ON event(ts);
+`;
+/**
+ * Do two declared paths collide? Same file (a lease's "::symbol" suffix is
+ * ignored — two tasks in one file still fight over it at merge), or one is a
+ * directory holding the other.
+ */
+export function pathsOverlap(a, b) {
+    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() {
+    const A = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+    const b = crypto.randomBytes(12);
+    const s = [...b].map((x) => A[x % A.length]).join("");
+    return `${s.slice(0, 4)}-${s.slice(4, 8)}-${s.slice(8, 12)}`;
+}
+export class RoomDB {
+    file;
+    db;
+    listeners = new Set();
+    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);
+        // Additive migrations for rooms created by older versions.
+        for (const sql of [
+            "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);
+            }
+            catch {
+                /* column already exists */
+            }
+        }
+    }
+    /** 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);
+        return () => this.listeners.delete(fn);
+    }
+    emit(type, opts = {}) {
+        const e = {
+            id: nanoid(10),
+            task_id: opts.task_id ?? null,
+            agent_id: opts.agent_id ?? null,
+            type,
+            payload: JSON.stringify(opts.payload ?? {}),
+            ts: Date.now(),
+        };
+        this.db
+            .prepare("INSERT INTO event (id, task_id, agent_id, type, payload, ts) VALUES (@id,@task_id,@agent_id,@type,@payload,@ts)")
+            .run(e);
+        for (const l of this.listeners)
+            l(e);
+        return e;
+    }
+    // ---- Session ------------------------------------------------------------
+    createSession(goal) {
+        const s = { id: nanoid(8), goal, status: "open", created_at: Date.now() };
+        this.db
+            .prepare("INSERT INTO session (id, goal, status, created_at) VALUES (@id,@goal,@status,@created_at)")
+            .run(s);
+        this.emit("session.created", { payload: s });
+        return s;
+    }
+    currentSession() {
+        return this.db
+            // 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 -------------------------------------------------------------
+    upsertAgent(a) {
+        const now = Date.now();
+        this.db
+            .prepare(`INSERT INTO agent (id, vendor, model, role, status, budget_cents, updated_at)
+         VALUES (@id,@vendor,@model,@role,'idle',@budget_cents,@now)
+         ON CONFLICT(id) DO UPDATE SET vendor=@vendor, model=@model, role=@role, updated_at=@now`)
+            .run({ ...a, budget_cents: a.budget_cents ?? 0, now });
+        this.emit("agent.joined", { agent_id: a.id, payload: a });
+        return this.getAgent(a.id);
+    }
+    getAgent(id) {
+        return this.db.prepare("SELECT * FROM agent WHERE id=?").get(id);
+    }
+    listAgents() {
+        return this.db.prepare("SELECT * FROM agent ORDER BY id").all();
+    }
+    setAgentStatus(id, status, worktree_path) {
+        this.db
+            .prepare("UPDATE agent SET status=?, worktree_path=COALESCE(?, worktree_path), updated_at=? WHERE id=?")
+            .run(status, worktree_path ?? null, Date.now(), id);
+        this.emit("agent.status", { agent_id: id, payload: { status } });
+    }
+    // ---- Tasks --------------------------------------------------------------
+    addTask(t) {
+        const now = Date.now();
+        const task = {
+            id: nanoid(6),
+            title: t.title,
+            spec: t.spec ?? "",
+            status: "backlog",
+            claimed_by: null,
+            progress_pct: 0,
+            depends_on: JSON.stringify(t.depends_on ?? []),
+            prefers: JSON.stringify(t.prefers ?? []),
+            files: JSON.stringify(t.files ?? []),
+            est_seconds: t.est_seconds ?? null,
+            created_at: now,
+            updated_at: now,
+        };
+        this.db
+            .prepare(`INSERT INTO task (id,title,spec,status,claimed_by,progress_pct,depends_on,prefers,files,est_seconds,created_at,updated_at)
+         VALUES (@id,@title,@spec,@status,@claimed_by,@progress_pct,@depends_on,@prefers,@files,@est_seconds,@created_at,@updated_at)`)
+            .run(task);
+        this.emit("task.added", { task_id: task.id, payload: task });
+        return task;
+    }
+    listTasks() {
+        return this.db.prepare("SELECT * FROM task ORDER BY created_at").all();
+    }
+    getTask(id) {
+        return this.db.prepare("SELECT * FROM task WHERE id=?").get(id);
+    }
+    /** Atomic claim: only succeeds if the task is still in backlog. Race-safe. */
+    claimTask(taskId, agentId) {
+        const claim = this.db.transaction(() => {
+            const t = this.getTask(taskId);
+            if (!t)
+                return { ok: false, reason: "no such task" };
+            if (t.status !== "backlog")
+                return { ok: false, reason: `already ${t.status}` };
+            const deps = JSON.parse(t.depends_on);
+            const unmet = deps.filter((d) => this.getTask(d)?.status !== "merged");
+            if (unmet.length)
+                return { ok: false, reason: `blocked on ${unmet.join(", ")}` };
+            this.db
+                .prepare("UPDATE task SET status='claimed', claimed_by=?, updated_at=? WHERE id=?")
+                .run(agentId, Date.now(), taskId);
+            return { ok: true };
+        });
+        const res = claim();
+        if (res.ok) {
+            this.setAgentStatus(agentId, "working");
+            this.emit("task.claimed", { task_id: taskId, agent_id: agentId });
+            return { ok: true, task: this.getTask(taskId) };
+        }
+        return res;
+    }
+    /**
+     * Start a fresh board for a new goal. Tasks, plans and file claims are
+     * per-goal; shared memory is kept — what agents learned carries forward.
+     */
+    clearBoard() {
+        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=?, 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). */
+    releaseTask(id) {
+        this.db.prepare("UPDATE task SET status='backlog', claimed_by=NULL, progress_pct=0, updated_at=? WHERE id=?").run(Date.now(), id);
+        this.emit("task.status", { task_id: id, payload: { status: "backlog" } });
+    }
+    /** Another agent takes over a task in flight (a rescue): it's theirs now, status unchanged until they start. */
+    reassignTask(id, agentId) {
+        this.db.prepare("UPDATE task SET claimed_by=?, updated_at=? WHERE id=?").run(agentId, Date.now(), id);
+    }
+    /** Public emit for Room-level events (asks, answers, assignments). */
+    publish(type, opts = {}) {
+        this.emit(type, opts);
+    }
+    setTaskStatus(id, status) {
+        this.db.prepare("UPDATE task SET status=?, updated_at=? WHERE id=?").run(status, Date.now(), id);
+        this.emit("task.status", { task_id: id, payload: { status } });
+    }
+    setProgress(id, pct, note = "") {
+        const clamped = Math.max(0, Math.min(100, Math.round(pct)));
+        this.db
+            .prepare("UPDATE task SET progress_pct=?, status=CASE WHEN status='claimed' THEN 'in_progress' ELSE status END, updated_at=? WHERE id=?")
+            .run(clamped, Date.now(), id);
+        this.emit("task.progress", { task_id: id, payload: { pct: clamped, note } });
+    }
+    /**
+     * The highest-value unblocked backlog task, optionally biased to an agent's
+     * strengths. A task whose files overlap work in flight (another task's
+     * declared files, or a live lease from huddle_announce_plan) waits its turn:
+     * prevention is cheaper than resolving the conflict afterwards.
+     */
+    nextBacklogTask(prefers = []) {
+        const busy = this.busyFiles();
+        const backlog = this.db.prepare("SELECT * FROM task WHERE status='backlog'").all().filter((t) => JSON.parse(t.depends_on).every((d) => this.getTask(d)?.status === "merged") &&
+            !JSON.parse(t.files ?? "[]").some((f) => busy.some((b) => pathsOverlap(f, b))));
+        if (!backlog.length)
+            return undefined;
+        const score = (t) => {
+            const tags = JSON.parse(t.prefers);
+            return tags.filter((x) => prefers.includes(x)).length;
+        };
+        backlog.sort((a, b) => score(b) - score(a) || a.created_at - b.created_at);
+        return backlog[0];
+    }
+    // ---- 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),
+            task_id: p.task_id,
+            agent_id: p.agent_id,
+            intent: p.intent,
+            touches: JSON.stringify(p.touches),
+            created_at: Date.now(),
+        };
+        this.db
+            .prepare("INSERT INTO plan (id,task_id,agent_id,intent,touches,created_at) VALUES (@id,@task_id,@agent_id,@intent,@touches,@created_at)")
+            .run(plan);
+        // Take soft leases on everything not already conflicting.
+        const expires = Date.now() + 30 * 60 * 1000;
+        const held = new Set(conflicts.map((c) => c.path));
+        for (const path of p.touches) {
+            if (held.has(path))
+                continue;
+            this.db
+                .prepare("INSERT INTO file_claim (path,held_by,task_id,expires_at) VALUES (?,?,?,?) ON CONFLICT(path) DO NOTHING")
+                .run(path, p.agent_id, p.task_id, expires);
+        }
+        this.emit("plan.announced", { task_id: p.task_id, agent_id: p.agent_id, payload: { intent: p.intent, touches: p.touches, conflicts } });
+        return { plan, conflicts };
+    }
+    /** 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();
+        const placeholders = touches.map(() => "?").join(",");
+        const rows = this.db
+            .prepare(`SELECT * FROM file_claim WHERE path IN (${placeholders}) AND expires_at > ?`)
+            .all(...touches, now);
+        return rows.filter((r) => r.held_by !== byAgent);
+    }
+    /** Files in flight right now: declared by claimed/running/merging tasks, or leased by an agent. */
+    busyFiles() {
+        const active = this.db.prepare("SELECT files FROM task WHERE status IN ('claimed','in_progress','review')").all();
+        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);
+    }
+    // Attach mode (room/live.ts) matches leases by path prefix, so it needs the
+    // raw rows and single-lease verbs rather than announcePlan's exact match.
+    /** Every unexpired lease. */
+    listClaims() {
+        return this.db.prepare("SELECT * FROM file_claim WHERE expires_at > ? ORDER BY path").all(Date.now());
+    }
+    /** Take one lease. False if someone else holds that exact path. */
+    leaseClaim(path, holder, taskId, expiresAt) {
+        this.db.prepare("DELETE FROM file_claim WHERE path=? AND expires_at <= ?").run(path, Date.now());
+        this.db
+            .prepare("INSERT INTO file_claim (path,held_by,task_id,expires_at) VALUES (?,?,?,?) ON CONFLICT(path) DO UPDATE SET expires_at=excluded.expires_at WHERE held_by=excluded.held_by")
+            .run(path, holder, taskId, expiresAt);
+        const row = this.db.prepare("SELECT held_by FROM file_claim WHERE path=?").get(path);
+        return row?.held_by === holder;
+    }
+    releaseClaim(path, holder) {
+        this.db.prepare("DELETE FROM file_claim WHERE path=? AND held_by=?").run(path, holder);
+    }
+    /** Keep a live holder's leases from expiring. */
+    renewClaims(holder, expiresAt) {
+        this.db.prepare("UPDATE file_claim SET expires_at=? WHERE held_by=?").run(expiresAt, holder);
+    }
+    /** Events of some types, oldest first, newer than `sinceTs`. */
+    eventsOfType(types, sinceTs = 0, limit = 200) {
+        if (!types.length)
+            return [];
+        const ph = types.map(() => "?").join(",");
+        return this.db
+            .prepare(`SELECT * FROM event WHERE type IN (${ph}) AND ts > ? ORDER BY ts DESC LIMIT ?`)
+            .all(...types, sinceTs, limit).reverse();
+    }
+    // ---- Members & invites (multiplayer) ------------------------------------
+    /** One-time invite. Expires in `ttlMs`; the code is returned once and stored hashed. */
+    createInvite(opts = {}) {
+        const code = inviteCode();
+        const expiresAt = Date.now() + (opts.ttlMs ?? 10 * 60_000);
+        this.db
+            .prepare("INSERT INTO invite (code_hash, role, for_name, github, expires_at) VALUES (?, ?, ?, ?, ?)")
+            .run(sha(code), opts.role ?? "member", opts.forName ?? null, opts.github ?? null, expiresAt);
+        return { code, expiresAt };
+    }
+    /** Look at an invite without using it (to know if it needs a GitHub proof). */
+    peekInvite(code) {
+        const inv = this.db.prepare("SELECT * FROM invite WHERE code_hash=?").get(sha(code.trim().toUpperCase()));
+        if (!inv)
+            return { ok: false, reason: "unknown invite code" };
+        if (inv.used_by)
+            return { ok: false, reason: "that invite was already used" };
+        if (inv.expires_at < Date.now())
+            return { ok: false, reason: "that invite expired — ask for a new one" };
+        return { ok: true, invite: { role: inv.role, github: inv.github ?? null, for_name: inv.for_name ?? null } };
+    }
+    /** Trade a valid, unused, unexpired invite for a member token. Atomic. */
+    redeemInvite(code, name, verifiedGithub = null) {
+        const tx = this.db.transaction(() => {
+            const inv = this.db.prepare("SELECT * FROM invite WHERE code_hash=?").get(sha(code.trim().toUpperCase()));
+            if (!inv)
+                return { ok: false, reason: "unknown invite code" };
+            if (inv.used_by)
+                return { ok: false, reason: "that invite was already used" };
+            if (inv.expires_at < Date.now())
+                return { ok: false, reason: "that invite expired — ask for a new one" };
+            if (inv.github && inv.github.toLowerCase() !== (verifiedGithub ?? "").toLowerCase())
+                return { ok: false, reason: `this invite is for @${inv.github} — prove it with your GitHub SSH key` };
+            const token = crypto.randomBytes(32).toString("hex");
+            const member = {
+                id: nanoid(8),
+                // A verified GitHub login is the name; otherwise what they told us.
+                name: (inv.github ?? name ?? inv.for_name ?? "guest").slice(0, 40) || "guest",
+                role: inv.role,
+                github: inv.github ?? null,
+                joined_at: Date.now(),
+                left_at: null,
+            };
+            this.db
+                .prepare("INSERT INTO member (id, name, role, github, token_hash, joined_at) VALUES (?, ?, ?, ?, ?, ?)")
+                .run(member.id, member.name, member.role, member.github, sha(token), member.joined_at);
+            this.db.prepare("UPDATE invite SET used_by=? WHERE code_hash=?").run(member.id, inv.code_hash);
+            return { ok: true, token, member };
+        });
+        const r = tx();
+        if (r.ok)
+            this.emit("member.joined", { payload: { id: r.member.id, name: r.member.name, role: r.member.role, github: r.member.github } });
+        return r;
+    }
+    /** The active member a token belongs to, if any. Left members never match. */
+    memberByToken(token) {
+        if (!token)
+            return undefined;
+        return this.db.prepare("SELECT id, name, role, github, joined_at, left_at FROM member WHERE token_hash=? AND left_at IS NULL").get(sha(token));
+    }
+    listMembers() {
+        return this.db.prepare("SELECT id, name, role, github, joined_at, left_at FROM member WHERE left_at IS NULL ORDER BY joined_at").all();
+    }
+    /** Leave (or be removed): instant, and the token stops working immediately. */
+    removeMember(id, reason = "left") {
+        const m = this.db.prepare("SELECT id, name, role, github, joined_at, left_at FROM member WHERE id=? AND left_at IS NULL").get(id);
+        if (!m)
+            return undefined;
+        this.db.prepare("UPDATE member SET left_at=? WHERE id=?").run(Date.now(), id);
+        this.emit("member.left", { payload: { id: m.id, name: m.name, reason } });
+        return m;
+    }
+    /** A message in the room. Always data for readers — never instructions to agents. */
+    postMessage(from, body) {
+        this.emit("message", { payload: { from: from.name, from_id: from.id, body: body.slice(0, 2000) } });
+    }
+    // ---- Agent-to-agent messages --------------------------------------------
+    /** Drop a message in `to`'s inbox. Data for the reader — never instructions to Huddle. */
+    sendMessage(m) {
+        const msg = {
+            id: nanoid(8),
+            from_agent: m.from,
+            to_agent: m.to,
+            body: m.body.slice(0, 4000),
+            kind: m.kind ?? "note",
+            reply_to: m.reply_to ?? null,
+            task_id: m.task_id ?? null,
+            created_at: Date.now(),
+            read_at: null,
+        };
+        this.db
+            .prepare(`INSERT INTO message (id,from_agent,to_agent,body,kind,reply_to,task_id,created_at,read_at)
+         VALUES (@id,@from_agent,@to_agent,@body,@kind,@reply_to,@task_id,@created_at,@read_at)`)
+            .run(msg);
+        this.emit("agent.message", {
+            task_id: msg.task_id,
+            agent_id: msg.from_agent,
+            payload: { id: msg.id, from: msg.from_agent, to: msg.to_agent, body: msg.body, kind: msg.kind, reply_to: msg.reply_to },
+        });
+        return msg;
+    }
+    getMessage(id) {
+        return this.db.prepare("SELECT * FROM message WHERE id=?").get(id);
+    }
+    /**
+     * 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 LIMIT ?")
+            .all(agent, opts.limit ?? -1);
+        if (!opts.peek)
+            for (const r of rows)
+                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, 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
+     * forget ids — the next plain message from the person asked back to the asker.
+     */
+    findAnswer(q) {
+        return this.db
+            .prepare(`SELECT * FROM message WHERE kind != 'question' AND (reply_to=@id OR
+           (reply_to IS NULL AND from_agent=@to AND to_agent=@from AND created_at >= @at))
+         ORDER BY created_at, rowid LIMIT 1`)
+            .get({ id: q.id, to: q.to_agent, from: q.from_agent, at: q.created_at });
+    }
+    // ---- 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`)
+            .run(taskId, agentId, taskId, summary.slice(0, 2000), Date.now());
+    }
+    saveHandoff(h) {
+        const prev = this.getHandoff(h.task_id);
+        const row = {
+            task_id: h.task_id,
+            agent_id: h.agent_id,
+            title: h.title,
+            summary: h.summary ?? prev?.summary ?? "",
+            files: JSON.stringify(h.files),
+            symbols: JSON.stringify(h.symbols),
+            notes: JSON.stringify(h.notes),
+            created_at: Date.now(),
+        };
+        this.db
+            .prepare(`INSERT OR REPLACE INTO handoff (task_id, agent_id, title, summary, files, symbols, notes, created_at)
+         VALUES (@task_id, @agent_id, @title, @summary, @files, @symbols, @notes, @created_at)`)
+            .run(row);
+        this.emit("handoff.ready", { task_id: h.task_id, agent_id: h.agent_id, payload: { files: h.files.length, symbols: h.symbols.length } });
+        return this.getHandoff(h.task_id);
+    }
+    getHandoff(taskId) {
+        const r = this.db.prepare("SELECT * FROM handoff WHERE task_id=?").get(taskId);
+        if (!r)
+            return undefined;
+        return { ...r, files: JSON.parse(r.files), symbols: JSON.parse(r.symbols), notes: JSON.parse(r.notes) };
+    }
+    // ---- Shared memory ------------------------------------------------------
+    remember(m) {
+        const mem = {
+            id: nanoid(8),
+            kind: m.kind,
+            body: m.body,
+            why: m.why ?? "",
+            author: m.author,
+            created_at: Date.now(),
+        };
+        this.db
+            .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) {
+        const all = this.db.prepare("SELECT * FROM memory ORDER BY created_at DESC").all();
+        if (!query)
+            return all;
+        const q = query.toLowerCase();
+        return all.filter((m) => (m.body + " " + m.why).toLowerCase().includes(q));
+    }
+    // ---- Events -------------------------------------------------------------
+    recentEvents(limit = 50) {
+        return this.db.prepare("SELECT * FROM event ORDER BY ts DESC LIMIT ?").all(limit);
+    }
+    /** Every event, oldest first (insertion order breaks ties) — `huddle story` replays runs from these. */
+    allEvents() {
+        return this.db.prepare("SELECT * FROM event ORDER BY ts, rowid").all();
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=db.js.map