@join-pantheon/cli 0.32.1 → 0.33.0-rc.2

package/dist/board.js

@@ -0,0 +1,1417 @@
+import { createServer } from "node:http";
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { spawn } from "node:child_process";
+import { chmodSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONFIG_DIR } from "./config.js";
+import { LIMITS } from "./protocol.js";
+import { childNodeFlags } from "./managed.js";
+import { which } from "./which.js";
+import { VERSION } from "./version.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const CLI_ENTRY = resolve(HERE, "cli.js");
+export const BOARD_IDLE_MS = 30 * 60_000;
+export const BOARD_REFRESH_MS = 15_000;
+export const LANES = [
+    { id: "now", title: "Needs you now", empty: "Nothing needs you right now." },
+    { id: "handling", title: "Handling", empty: "Your agents are not working on anything for the team." },
+    { id: "waiting", title: "Waiting", empty: "You are not waiting on anyone." },
+    { id: "older", title: "Older", empty: "Nothing has been stuck for over a week." },
+];
+export const boardStatePath = (home = CONFIG_DIR) => join(home, "board.json");
+export function readBoardState(home = CONFIG_DIR) {
+    try {
+        const s = JSON.parse(readFileSync(boardStatePath(home), "utf8"));
+        if (!Number.isInteger(s.pid) || !Number.isInteger(s.port) || typeof s.token !== "string" || !TOKEN_RE.test(s.token))
+            return null;
+        return { pid: s.pid, port: s.port, token: s.token, started: Number(s.started) || 0, keep: !!s.keep, version: String(s.version ?? "") };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeBoardState(s, home = CONFIG_DIR) {
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    const file = boardStatePath(home);
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(s) + "\n", { mode: 0o600 });
+    try {
+        chmodSync(tmp, 0o600);
+    }
+    catch { }
+    renameSync(tmp, file);
+}
+export function clearBoardState(pid, home = CONFIG_DIR) {
+    const s = readBoardState(home);
+    if (s && s.pid === pid)
+        rmSync(boardStatePath(home), { force: true });
+}
+export const LINK_TTL_MS = 30_000;
+export const boardLink = (port, nonce) => `http://127.0.0.1:${port}/#open=${nonce}`;
+const TOKEN_RE = /^[0-9a-f]{64}$/;
+const ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
+const MAX_BODY_BYTES = 64 * 1024;
+const SENT_KEEP_MS = 10 * 60_000;
+export function defaultBoardDeps(home = CONFIG_DIR) {
+    return {
+        status: async () => (await import("./tray.js")).trayStatus(),
+        cli: runCli,
+        actionFile: join(home, "bin", ".hud-action.json"),
+        openTerminal: (actionId) => openExplainTerminal(home, actionId),
+        now: Date.now,
+        peerUid: (c, b) => loopbackPeerUid(c, b),
+    };
+}
+export function loopbackPeerUid(clientPort, boardPort, read = (p) => readFileSync(p, "utf8"), os = platform()) {
+    if (os !== "linux")
+        return null;
+    const hex = (n) => n.toString(16).toUpperCase().padStart(4, "0");
+    const at = (p) => [`0100007F:${hex(p)}`, `0000000000000000FFFF00000100007F:${hex(p)}`];
+    const locals = at(clientPort), remotes = at(boardPort);
+    let readable = false;
+    for (const f of ["/proc/net/tcp", "/proc/net/tcp6"]) {
+        let text;
+        try {
+            text = read(f);
+            readable = true;
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split("\n").slice(1)) {
+            const w = line.trim().split(/\s+/);
+            if (w.length < 8 || !locals.includes(w[1].toUpperCase()) || !remotes.includes(w[2].toUpperCase()))
+                continue;
+            const uid = Number(w[7]);
+            if (Number.isInteger(uid))
+                return uid;
+        }
+    }
+    return readable ? -1 : null;
+}
+export function runCli(args, timeoutMs, env = process.env) {
+    return new Promise((done) => {
+        let out = "", err = "";
+        const child = spawn(process.execPath, [...childNodeFlags(), CLI_ENTRY, ...args], {
+            stdio: ["ignore", "pipe", "pipe"], windowsHide: true, env: { ...env, NO_COLOR: "1" },
+        });
+        const t = setTimeout(() => { try {
+            child.kill();
+        }
+        catch { } }, timeoutMs);
+        child.stdout.on("data", (d) => { if (out.length < 4 * 1024 * 1024)
+            out += d.toString(); });
+        child.stderr.on("data", (d) => { if (err.length < 1024 * 1024)
+            err += d.toString(); });
+        child.on("error", (e) => { clearTimeout(t); done({ code: null, out, err: err + e.message }); });
+        child.on("close", (code) => { clearTimeout(t); done({ code, out, err }); });
+    });
+}
+const sha = (s) => createHash("sha256").update(s).digest();
+const same = (a, b) => timingSafeEqual(sha(a), sha(b));
+const keyOf = (s) => createHash("sha256").update(s).digest("hex");
+export const pingProof = (token, port, challenge) => createHmac("sha256", token).update(`pantheon-board-ping:${port}:${challenge}`).digest("hex");
+const MAX_LINKS = 32;
+const MAX_SESSIONS = 64;
+const BASE_HEADERS = {
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff",
+    "Referrer-Policy": "no-referrer",
+    "X-Frame-Options": "DENY",
+    "Cross-Origin-Resource-Policy": "same-origin",
+    "Cross-Origin-Opener-Policy": "same-origin",
+};
+function sendJson(res, status, body, extra = {}) {
+    const data = JSON.stringify(body);
+    res.writeHead(status, { ...BASE_HEADERS, "Content-Type": "application/json; charset=utf-8", "Content-Length": Buffer.byteLength(data), ...extra });
+    res.end(data);
+}
+function readBody(req) {
+    return new Promise((done) => {
+        let size = 0;
+        const parts = [];
+        let over = false;
+        req.on("data", (d) => { size += d.length; if (size > MAX_BODY_BYTES) {
+            over = true;
+            return;
+        } parts.push(d); });
+        req.on("end", () => done(over ? null : Buffer.concat(parts).toString("utf8")));
+        req.on("error", () => done(null));
+    });
+}
+function strictObject(raw, allowed) {
+    if (raw === null)
+        return null;
+    let v;
+    try {
+        v = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return null;
+    for (const k of Object.keys(v))
+        if (!allowed.includes(k))
+            return null;
+    return v;
+}
+const str = (v, re) => (typeof v === "string" && re.test(v) ? v : null);
+const SPACE_RE = /^[^\u0000-\u001f\u007f]{1,100}$/;
+export function explainOutcome(r, nonce) {
+    const out = r.out.trim();
+    const notSent = /^not sent: (.*)$/m.exec(out);
+    if (notSent)
+        return { ok: false, message: notSent[1].trim() };
+    if (nonce !== undefined && !new RegExp(`^action ${nonce}$`, "m").test(out)) {
+        return { ok: false, message: "another window took that action before it ran — nothing was sent from here; try again" };
+    }
+    const sent = /^sent (ANSWER|NOTE|ASK|RETRACT) id=(\S+)/m.exec(out);
+    if (r.code === 0 && sent)
+        return { ok: true, message: `sent ${sent[1]}`, sent: { kind: sent[1], id: sent[2] } };
+    const err = r.err.replace(/\x1b\[[0-9;]*m/g, "");
+    if (r.code === 0 && /^done — /m.test(err))
+        return { ok: true, message: "Done — it is no longer waiting on you." };
+    if (r.code === 0 && /no longer waiting on you/.test(err))
+        return { ok: true, message: "It was already settled — it is no longer waiting on you." };
+    if (r.code === 0)
+        return { ok: true, message: "Done." };
+    const last = err.split("\n").map((l) => l.trim()).filter((l) => l && !/^pantheon \d|update available|upgrade/i.test(l)).at(-1);
+    return { ok: false, message: last ? last.slice(0, 300) : "the relay could not be reached" };
+}
+export function hudActionFor(op, item) {
+    const ref = item.ref ? { act: item.ref } : {};
+    const space = item.space ? { space: item.space } : {};
+    const goal = item.goal ? { goal: item.goal } : {};
+    switch (op.op) {
+        case "done":
+            if (item.kind !== "decision")
+                return { error: "only your own decision can be marked done" };
+            return { action: "done", decision: item.id, ...space, ...ref };
+        case "choose": {
+            const c = item.choices?.[op.index];
+            if (!c)
+                return { error: "that choice is not on this item" };
+            return { action: "reply", kind: "ANSWER", body: c.answer, ...goal, ...space, decision: item.id, ...ref };
+        }
+        case "reply":
+            if (op.kind === "ANSWER" && item.kind !== "decision")
+                return { error: "only the person it waits on can answer it — add a note or ask back" };
+            return { action: "reply", kind: op.kind, body: op.body, ...goal, ...space, ...(item.kind === "decision" ? { decision: item.id } : {}), ...ref };
+        case "open":
+            return { action: "open", prompt: item.prompt, ...space, ...goal, ...(item.kind === "decision" ? { decision: item.id } : {}) };
+    }
+}
+export function parseBoardAction(raw) {
+    const v = strictObject(raw, ["op", "id", "space", "index", "kind", "body", "act"]);
+    if (!v)
+        return null;
+    const space = v.space === undefined ? undefined : str(v.space, SPACE_RE);
+    if (space === null)
+        return null;
+    const sp = space === undefined ? {} : { space };
+    if (v.op === "retract") {
+        const act = str(v.act, ID_RE);
+        return act && Object.keys(v).every((k) => ["op", "act"].includes(k)) ? { op: "retract", act } : null;
+    }
+    const id = str(v.id, ID_RE);
+    if (!id)
+        return null;
+    const only = (keys) => Object.keys(v).every((k) => ["op", "id", "space", ...keys].includes(k));
+    switch (v.op) {
+        case "done": return only([]) ? { op: "done", id, ...sp } : null;
+        case "open": return only([]) ? { op: "open", id, ...sp } : null;
+        case "choose":
+            return only(["index"]) && Number.isInteger(v.index) && v.index >= 0 && v.index < 10
+                ? { op: "choose", id, ...sp, index: v.index } : null;
+        case "reply": {
+            if (!only(["kind", "body"]))
+                return null;
+            if (v.kind !== "ANSWER" && v.kind !== "NOTE" && v.kind !== "ASK")
+                return null;
+            if (typeof v.body !== "string")
+                return null;
+            const body = v.body.trim();
+            if (!body || body.length > LIMITS.bodyChars)
+                return null;
+            return { op: "reply", id, ...sp, kind: v.kind, body };
+        }
+        default: return null;
+    }
+}
+export async function startBoardServer(o = {}) {
+    const home = o.home ?? CONFIG_DIR;
+    const deps = { ...defaultBoardDeps(home), ...(o.deps ?? {}) };
+    const token = o.token ?? randomBytes(32).toString("hex");
+    if (!TOKEN_RE.test(token))
+        throw new Error("a board token is 64 hex characters");
+    const idleMs = o.idleMs ?? BOARD_IDLE_MS;
+    let keep = !!o.keep;
+    let lastSeen = deps.now();
+    let port = 0;
+    let lastStatus = null;
+    const sent = new Map();
+    let chain = Promise.resolve();
+    const serial = (fn) => { const p = chain.then(fn, fn); chain = p.catch(() => { }); return p; };
+    const origins = () => [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
+    const links = new Map();
+    const sessions = new Set();
+    const mintLink = () => {
+        const now = deps.now();
+        for (const [k, until] of links)
+            if (until <= now)
+                links.delete(k);
+        while (links.size >= MAX_LINKS)
+            links.delete(links.keys().next().value);
+        const nonce = randomBytes(32).toString("hex");
+        links.set(keyOf(nonce), now + LINK_TTL_MS);
+        return boardLink(port, nonce);
+    };
+    const useLink = (nonce) => {
+        const k = keyOf(nonce);
+        const until = links.get(k);
+        links.delete(k);
+        return until !== undefined && until > deps.now();
+    };
+    const bearerOf = (req) => /^Bearer ([0-9a-f]{64})$/.exec(req.headers.authorization ?? "")?.[1] ?? null;
+    const authed = (req) => {
+        const b = bearerOf(req);
+        if (!b)
+            return null;
+        if (same(b, token))
+            return "token";
+        return sessions.has(keyOf(b)) ? "session" : null;
+    };
+    const peerChecked = new WeakMap();
+    const samePerson = (req) => {
+        const sock = req.socket;
+        const known = peerChecked.get(sock);
+        if (known !== undefined)
+            return known;
+        const me = typeof process.getuid === "function" ? process.getuid() : null;
+        const addr = sock.remoteAddress ?? "";
+        let ok = addr === "127.0.0.1" || addr === "::ffff:127.0.0.1";
+        if (ok && me !== null && sock.remotePort) {
+            const uid = deps.peerUid(sock.remotePort, port);
+            ok = uid === null || uid === me;
+        }
+        peerChecked.set(sock, ok);
+        return ok;
+    };
+    const status = async () => {
+        const s = await deps.status();
+        lastStatus = { at: deps.now(), status: s };
+        return s;
+    };
+    const findItem = async (id, space) => {
+        const match = (s) => (s.items ?? []).find((i) => i.id === id && (space === undefined || (i.space ?? "") === space)) ?? null;
+        if (lastStatus && deps.now() - lastStatus.at < 2 * 60_000) {
+            const hit = match(lastStatus.status);
+            if (hit)
+                return hit;
+        }
+        return match(await status());
+    };
+    const knownSpace = async (space) => {
+        const s = lastStatus?.status ?? await status();
+        return (s.spaces ?? (s.space ? [s.space] : [])).includes(space);
+    };
+    const writeAction = (a) => {
+        mkdirSync(dirname(deps.actionFile), { recursive: true });
+        const tmp = `${deps.actionFile}.${process.pid}.board.tmp`;
+        const nonce = randomBytes(16).toString("hex");
+        const text = JSON.stringify({ ...a, nonce });
+        writeFileSync(tmp, text, { mode: 0o600 });
+        renameSync(tmp, deps.actionFile);
+        return { text, nonce };
+    };
+    const ours = (text) => { try {
+        return readFileSync(deps.actionFile, "utf8") === text;
+    }
+    catch {
+        return false;
+    } };
+    const dropOurs = (text) => { if (ours(text)) {
+        try {
+            rmSync(deps.actionFile, { force: true });
+        }
+        catch { }
+    } };
+    const runQueued = (a) => serial(async () => {
+        const { text, nonce } = writeAction(a);
+        try {
+            return { r: await deps.cli(["explain", "--queued", "--only-action", "--action-id", nonce], 30_000), nonce };
+        }
+        finally {
+            dropOurs(text);
+        }
+    });
+    const openQueued = (a) => serial(async () => {
+        const { text, nonce } = writeAction(a);
+        const r = await deps.openTerminal(nonce).catch((e) => ({ ok: false, why: e.message }));
+        if (!r.ok) {
+            dropOurs(text);
+            return r;
+        }
+        const until = deps.now() + 25_000;
+        while (ours(text) && deps.now() < until)
+            await new Promise((r2) => setTimeout(r2, 200));
+        if (ours(text)) {
+            dropOurs(text);
+            return { ok: false, why: "the terminal did not start in time — try again, or copy the question into your agent" };
+        }
+        return { ok: true };
+    });
+    const handle = async (req, res) => {
+        const host = req.headers.host ?? "";
+        if (host !== `127.0.0.1:${port}` && host !== `localhost:${port}`) {
+            sendJson(res, 403, { ok: false, error: "wrong host" });
+            return;
+        }
+        if (!samePerson(req)) {
+            sendJson(res, 403, { ok: false, error: "this board belongs to another user on this computer" });
+            return;
+        }
+        const site = req.headers["sec-fetch-site"];
+        if (typeof site === "string" && site !== "same-origin" && site !== "none") {
+            sendJson(res, 403, { ok: false, error: "cross-site request" });
+            return;
+        }
+        const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+        const method = req.method ?? "GET";
+        if (method !== "GET" && method !== "POST") {
+            sendJson(res, 405, { ok: false, error: "method not allowed" }, { Allow: "GET, POST" });
+            return;
+        }
+        if (method === "POST") {
+            if (!origins().includes(String(req.headers.origin ?? ""))) {
+                sendJson(res, 403, { ok: false, error: "foreign origin" });
+                return;
+            }
+            if (!/^application\/json(;|$)/i.test(String(req.headers["content-type"] ?? ""))) {
+                sendJson(res, 415, { ok: false, error: "JSON only" });
+                return;
+            }
+        }
+        if (method === "GET" && url.pathname === "/") {
+            const nonce = randomBytes(16).toString("base64");
+            const html = boardHtml(nonce);
+            res.writeHead(200, {
+                ...BASE_HEADERS,
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Length": Buffer.byteLength(html),
+                "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; img-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`,
+            });
+            res.end(html);
+            return;
+        }
+        if (method === "POST" && url.pathname === "/api/session") {
+            const nonce = bearerOf(req);
+            const body = strictObject(await readBody(req), []);
+            if (!nonce || !useLink(nonce)) {
+                sendJson(res, 401, { ok: false, error: "this board link has expired or was already used — run pantheon board for a fresh one" });
+                return;
+            }
+            if (body === null) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            const session = randomBytes(32).toString("hex");
+            while (sessions.size >= MAX_SESSIONS)
+                sessions.delete(sessions.values().next().value);
+            sessions.add(keyOf(session));
+            lastSeen = deps.now();
+            sendJson(res, 200, { ok: true, session });
+            return;
+        }
+        if (method === "GET" && url.pathname === "/api/ping") {
+            const challenge = str(url.searchParams.get("challenge"), /^[0-9a-f]{32,128}$/);
+            if (authed(req))
+                lastSeen = deps.now();
+            sendJson(res, 200, { ok: true, board: true, pid: process.pid, version: VERSION, keep, ...(challenge ? { proof: pingProof(token, port, challenge) } : {}) });
+            return;
+        }
+        const who = authed(req);
+        if (!who) {
+            sendJson(res, 401, { ok: false, error: "this board needs its link — run pantheon board to open it" });
+            return;
+        }
+        lastSeen = deps.now();
+        if (method === "POST" && url.pathname === "/api/link") {
+            if (who !== "token") {
+                sendJson(res, 403, { ok: false, error: "links are made by pantheon board" });
+                return;
+            }
+            if (strictObject(await readBody(req), []) === null) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            sendJson(res, 200, { ok: true, link: mintLink(), ttl_ms: LINK_TTL_MS });
+            return;
+        }
+        if (method === "POST" && url.pathname === "/api/keep") {
+            if (strictObject(await readBody(req), []) === null) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            keep = true;
+            sendJson(res, 200, { ok: true, keep });
+            return;
+        }
+        if (method === "POST" && url.pathname === "/api/stop") {
+            if (strictObject(await readBody(req), []) === null) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            sendJson(res, 200, { ok: true });
+            setTimeout(() => { void close().then(() => o.onIdle?.()); }, 20);
+            return;
+        }
+        if (method === "GET" && url.pathname === "/api/board") {
+            try {
+                sendJson(res, 200, { ok: true, at: deps.now(), refresh_ms: BOARD_REFRESH_MS, status: await status() });
+            }
+            catch (e) {
+                sendJson(res, 200, { ok: false, error: `could not read the board: ${e.message}` });
+            }
+            return;
+        }
+        if (method === "GET" && url.pathname === "/api/detail") {
+            const id = str(url.searchParams.get("id"), ID_RE);
+            const space = url.searchParams.get("space");
+            if (!id || (space !== null && (!str(space, SPACE_RE) || !(await knownSpace(space))))) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            const r = await deps.cli(["tray-detail", id, ...(space ? ["--space", space] : [])], 20_000);
+            try {
+                sendJson(res, 200, JSON.parse(r.out.trim().split("\n").at(-1) ?? ""));
+            }
+            catch {
+                sendJson(res, 200, { ok: false });
+            }
+            return;
+        }
+        if (method === "GET" && url.pathname === "/api/thread") {
+            const goal = str(url.searchParams.get("goal"), ID_RE);
+            const space = url.searchParams.get("space");
+            if (!goal || !space || !str(space, SPACE_RE) || !(await knownSpace(space))) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            const teams = lastStatus?.status.spaces ?? [];
+            const r = await deps.cli(["history", "--goal", goal, "--json", "--last", "40", ...(teams.length > 1 ? ["--space", space] : [])], 20_000);
+            try {
+                const acts = JSON.parse(r.out);
+                sendJson(res, 200, { ok: true, acts: acts.map((a) => ({ id: String(a.id ?? ""), act: String(a.act ?? ""), from: String(a.from ?? ""), ts: Number(a.ts) || 0, body: String(a.body ?? "").slice(0, 6000), ...(a.summary ? { summary: String(a.summary) } : {}) })) });
+            }
+            catch {
+                sendJson(res, 200, { ok: false, error: "the thread could not be read" });
+            }
+            return;
+        }
+        if (method === "POST" && url.pathname === "/api/action") {
+            const op = parseBoardAction(await readBody(req));
+            if (!op) {
+                sendJson(res, 400, { ok: false, error: "bad request" });
+                return;
+            }
+            if (op.op === "retract") {
+                const s = sent.get(op.act);
+                if (!s || deps.now() - s.at > SENT_KEEP_MS) {
+                    sendJson(res, 400, { ok: false, error: "only something this board just sent can be retracted" });
+                    return;
+                }
+                const q = await runQueued({ action: "retract", act: op.act, ...(s.space ? { space: s.space } : {}) });
+                const r = explainOutcome(q.r, q.nonce);
+                if (r.ok)
+                    sent.delete(op.act);
+                sendJson(res, 200, { ok: r.ok, message: r.ok ? "Retracted." : r.message });
+                return;
+            }
+            const item = await findItem(op.id, op.space);
+            if (!item) {
+                sendJson(res, 200, { ok: false, message: "that is no longer on your board" });
+                return;
+            }
+            const hud = hudActionFor(op, item);
+            if ("error" in hud) {
+                sendJson(res, 400, { ok: false, error: hud.error });
+                return;
+            }
+            if (op.op === "open") {
+                const r = await openQueued(hud);
+                sendJson(res, 200, { ok: r.ok, message: r.ok ? "Opening your agent in a terminal…" : (r.why ?? "no terminal could be opened here — copy the question into your agent") });
+                return;
+            }
+            const q = await runQueued(hud);
+            const r = explainOutcome(q.r, q.nonce);
+            if (r.sent) {
+                sent.set(r.sent.id, { ...(item.space ? { space: item.space } : {}), at: deps.now() });
+                for (const [k, v] of sent)
+                    if (deps.now() - v.at > SENT_KEEP_MS)
+                        sent.delete(k);
+            }
+            sendJson(res, 200, { ok: r.ok, message: r.message, ...(r.sent ? { sent: r.sent.id } : {}) });
+            return;
+        }
+        sendJson(res, 404, { ok: false, error: "not found" });
+    };
+    const server = createServer((req, res) => {
+        handle(req, res).catch((e) => { try {
+            sendJson(res, 500, { ok: false, error: e.message });
+        }
+        catch { } });
+    });
+    server.headersTimeout = 15_000;
+    server.requestTimeout = 60_000;
+    await new Promise((ok, fail) => { server.once("error", fail); server.listen(0, "127.0.0.1", () => { server.off("error", fail); ok(); }); });
+    port = server.address().port;
+    let closed = false;
+    const timer = setInterval(() => {
+        if (keep || closed)
+            return;
+        if (deps.now() - lastSeen > idleMs) {
+            void close().then(() => o.onIdle?.());
+        }
+    }, o.idleCheckMs ?? 30_000);
+    timer.unref?.();
+    async function close() {
+        if (closed)
+            return;
+        closed = true;
+        clearInterval(timer);
+        await new Promise((r) => { server.close(() => r()); server.closeAllConnections?.(); });
+    }
+    return { port, token, get url() { return mintLink(); }, link: mintLink, server, get keep() { return keep; }, close, lastSeen: () => lastSeen };
+}
+const LINK_RE = /^http:\/\/127\.0\.0\.1:\d{1,5}\/#open=[0-9a-f]{64}$/;
+export function inServiceCgroup(read = (p) => readFileSync(p, "utf8"), os = platform()) {
+    if (os !== "linux")
+        return false;
+    let text;
+    try {
+        text = read("/proc/self/cgroup");
+    }
+    catch {
+        return false;
+    }
+    const line = text.split("\n").find((l) => l.startsWith("0::")) ?? text.split("\n").find((l) => l.includes(":name=systemd:"));
+    const path = line?.slice(line.indexOf(":", line.indexOf(":") + 1) + 1).trim() ?? "";
+    return /\.service$/.test(path.replace(/\/+$/, ""));
+}
+export function scopeArgv(argv, find = (n) => which(n)) {
+    const sr = find("systemd-run");
+    return sr ? [sr, "--user", "--scope", "--collect", "--quiet", "--", ...argv] : null;
+}
+export function browserCommand(url, os = platform(), find = (n) => which(n), o = {}) {
+    if (!LINK_RE.test(url))
+        throw new Error("not a board link");
+    const opts = { detached: true, stdio: "ignore", windowsHide: true };
+    if (os === "darwin")
+        return { cmd: "open", args: [url], opts };
+    if (os === "win32")
+        return { cmd: "cmd.exe", args: ["/d", "/c", "start", '""', url], opts: { ...opts, windowsVerbatimArguments: true } };
+    const x = find("xdg-open");
+    if (!x)
+        return null;
+    const scoped = o.scope ? scopeArgv([x, url], find) : null;
+    return scoped ? { cmd: scoped[0], args: scoped.slice(1), opts } : { cmd: x, args: [url], opts };
+}
+export function redirectPage(url, dir, now = Date.now()) {
+    if (!LINK_RE.test(url))
+        throw new Error("not a board link");
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (const f of readdirSync(dir)) {
+        if (!/^board-open-[0-9a-f]{16}\.html$/.test(f))
+            continue;
+        try {
+            if (now - statSync(join(dir, f)).mtimeMs > 60_000)
+                rmSync(join(dir, f), { force: true });
+        }
+        catch { }
+    }
+    const file = join(dir, `board-open-${randomBytes(8).toString("hex")}.html`);
+    writeFileSync(file, `<!doctype html><meta charset="utf-8"><meta name="referrer" content="no-referrer"><meta http-equiv="refresh" content="0;url=${url}"><title>Pantheon</title><script>location.replace(${JSON.stringify(url)})</script>\n`, { mode: 0o600 });
+    return file;
+}
+export function fileOpenCommand(file, os = platform()) {
+    const opts = { detached: true, stdio: "ignore", windowsHide: true };
+    if (os === "darwin")
+        return { cmd: "open", args: [file], opts };
+    if (os === "win32")
+        return { cmd: "explorer.exe", args: [file], opts };
+    return null;
+}
+export async function openBrowser(url, d = {}) {
+    if (!LINK_RE.test(url))
+        throw new Error("not a board link");
+    const os = d.os ?? platform();
+    const find = d.find ?? ((n) => which(n));
+    if (os === "linux") {
+        const portal = d.portal ?? (async (u) => (await import("./notice-linux.js")).portalOpenUri(u));
+        if (await portal(url).catch(() => false))
+            return "portal";
+    }
+    if (os === "darwin" || os === "win32") {
+        const page = redirectPage(url, d.pageDir ?? join(CONFIG_DIR, "bin"));
+        const how = fileOpenCommand(page, os);
+        return (await (d.launch ?? launch)(how)) ? "direct" : false;
+    }
+    const scope = os === "linux" && (d.inService ?? (() => inServiceCgroup()))();
+    const how = browserCommand(url, os, find, { scope });
+    if (!how)
+        return false;
+    if (!(await (d.launch ?? launch)(how)))
+        return false;
+    return how.cmd.endsWith("systemd-run") ? "scope" : "direct";
+}
+export function launch(l) {
+    return new Promise((done) => {
+        try {
+            const child = spawn(l.cmd, l.args, l.opts);
+            child.once("error", () => done(false));
+            child.once("spawn", () => { child.unref(); done(true); });
+        }
+        catch {
+            done(false);
+        }
+    });
+}
+export function terminalCommand(home, actionId, os = platform(), env = process.env, find = (n) => which(n), node = process.execPath, entry = CLI_ENTRY) {
+    if (!/^[0-9a-f]{16,64}$/.test(actionId))
+        return { error: "not an action id" };
+    const argv = [node, ...childNodeFlags(), entry, "explain", "--queued", "--only-action", "--action-id", actionId];
+    const opts = { detached: true, stdio: "ignore", env };
+    if (os === "darwin") {
+        const file = join(home, "bin", "pantheon-board-explain.command");
+        const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, `#!/bin/zsh\n${argv.map(q).join(" ")}\n`, { mode: 0o700 });
+        try {
+            chmodSync(file, 0o700);
+        }
+        catch { }
+        return { cmd: "open", args: [file], opts };
+    }
+    if (os === "win32") {
+        if (argv.some((a) => /["%\r\n]/.test(a)))
+            return { error: "the path to Pantheon holds a character the Windows console cannot pass safely" };
+        const line = `start "Pantheon" ${argv.map((a) => `"${a}"`).join(" ")}`;
+        return { cmd: "cmd.exe", args: ["/d", "/s", "/c", `"${line}"`], opts: { ...opts, windowsVerbatimArguments: true, windowsHide: true } };
+    }
+    if (!env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return { error: "there is no desktop here to open a terminal on" };
+    const terms = [
+        ["x-terminal-emulator", ["-e"]], ["gnome-terminal", ["--"]], ["konsole", ["-e"]], ["xfce4-terminal", ["-x"]],
+        ["kitty", []], ["alacritty", ["-e"]], ["wezterm", ["start", "--"]], ["xterm", ["-e"]],
+    ];
+    for (const [name, pre] of terms) {
+        const bin = find(name);
+        if (bin)
+            return { cmd: bin, args: [...pre, ...argv], opts };
+    }
+    return { error: "no terminal program was found (x-terminal-emulator, gnome-terminal, konsole, xterm …)" };
+}
+async function openExplainTerminal(home, actionId) {
+    const t = terminalCommand(home, actionId);
+    if ("error" in t)
+        return { ok: false, why: `${t.error} — copy the question into your agent instead` };
+    return (await launch(t)) ? { ok: true } : { ok: false, why: "the terminal could not be started — copy the question into your agent instead" };
+}
+export async function ping(s, timeoutMs = 1500) {
+    const challenge = randomBytes(16).toString("hex");
+    try {
+        const res = await fetch(`http://127.0.0.1:${s.port}/api/ping?challenge=${challenge}`, { signal: AbortSignal.timeout(timeoutMs), redirect: "error" });
+        if (!res.ok)
+            return false;
+        const j = await res.json();
+        if (j.board !== true || j.pid !== s.pid || typeof j.proof !== "string" || !/^[0-9a-f]{64}$/.test(j.proof))
+            return false;
+        return timingSafeEqual(Buffer.from(j.proof, "hex"), Buffer.from(pingProof(s.token, s.port, challenge), "hex"));
+    }
+    catch {
+        return false;
+    }
+}
+export async function boardPost(s, path, body = {}) {
+    return fetch(`http://127.0.0.1:${s.port}${path}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${s.token}`, Origin: `http://127.0.0.1:${s.port}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body), signal: AbortSignal.timeout(3000),
+    });
+}
+const pidAlive = (pid) => { try {
+    process.kill(pid, 0);
+    return true;
+}
+catch {
+    return false;
+} };
+export function pidOwner(pid, os = platform()) {
+    if (os !== "linux")
+        return null;
+    try {
+        return statSync(`/proc/${pid}`).uid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runningBoard(home = CONFIG_DIR) {
+    const s = readBoardState(home);
+    if (!s || !pidAlive(s.pid))
+        return null;
+    const me = typeof process.getuid === "function" ? process.getuid() : null;
+    const owner = pidOwner(s.pid);
+    if (me !== null && owner !== null && owner !== me)
+        return null;
+    return (await ping(s)) ? s : null;
+}
+export async function boardLinkFor(s) {
+    const r = await boardPost(s, "/api/link");
+    const j = await r.json().catch(() => null);
+    const link = j?.link;
+    if (!r.ok || !j?.ok || typeof link !== "string" || !LINK_RE.test(link) || !link.startsWith(`http://127.0.0.1:${s.port}/`)) {
+        throw new Error("the board did not hand out a link — run pantheon board --stop, then pantheon board");
+    }
+    return link;
+}
+export async function ensureBoard(o = {}) {
+    const home = o.home ?? CONFIG_DIR;
+    const up = await runningBoard(home);
+    if (up) {
+        if (o.keep && !up.keep)
+            await boardPost(up, "/api/keep").catch(() => null);
+        return { state: up, url: await boardLinkFor(up), reused: true };
+    }
+    const before = readBoardState(home);
+    (o.start ?? (() => {
+        const argv = [process.execPath, ...childNodeFlags(), CLI_ENTRY, "board", "--serve", ...(o.keep ? ["--keep"] : [])];
+        const start = (run) => {
+            const child = spawn(run[0], run.slice(1), { detached: true, stdio: "ignore", windowsHide: true, cwd: homedir(), env: process.env });
+            child.unref();
+            return child;
+        };
+        const scoped = inServiceCgroup() ? scopeArgv(argv) : null;
+        if (!scoped) {
+            start(argv).on("error", () => { });
+            return;
+        }
+        let fell = false;
+        const fallBack = () => { if (!fell) {
+            fell = true;
+            start(argv).on("error", () => { });
+        } };
+        const c = start(scoped);
+        c.on("error", fallBack);
+        c.on("exit", (code) => { if (code !== 0 && code !== null)
+            fallBack(); });
+    }))();
+    const until = Date.now() + (o.waitMs ?? 15_000);
+    while (Date.now() < until) {
+        await new Promise((r) => setTimeout(r, 150));
+        const s = readBoardState(home);
+        if (s && (!before || s.pid !== before.pid || s.started !== before.started) && await ping(s))
+            return { state: s, url: await boardLinkFor(s), reused: false };
+    }
+    throw new Error("the board did not start — run pantheon board --serve to see why");
+}
+export async function serveBoard(o = {}) {
+    const home = o.home ?? CONFIG_DIR;
+    if (await runningBoard(home))
+        return;
+    let resolveDone;
+    const done = new Promise((r) => { resolveDone = r; });
+    const b = await startBoardServer({ keep: !!o.keep, home, onIdle: () => resolveDone() });
+    writeBoardState({ pid: process.pid, port: b.port, token: b.token, started: Date.now(), keep: !!o.keep, version: VERSION }, home);
+    const stop = () => { void b.close().then(() => resolveDone()); };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    await done;
+    clearBoardState(process.pid, home);
+}
+export const termSafe = (s) => s.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]+/g, " ").replace(/\s+/g, " ").trim();
+export function ago(ms, now) {
+    if (!ms)
+        return "";
+    const s = Math.max(0, Math.round((now - ms) / 1000));
+    if (s < 60)
+        return "just now";
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h}h ago`;
+    return `${Math.round(h / 24)}d ago`;
+}
+const arg = (s) => (/^[A-Za-z0-9._@:/-]+$/.test(s) ? s : `"${s.replace(/["\\$`%]/g, "")}"`);
+export function watchCommands(i, multi) {
+    const sp = i.space ? ` --space ${arg(i.space)}` : "";
+    if (i.kind === "decision") {
+        const team = multi && i.space ? ` --space ${arg(i.space)}` : "";
+        const out = i.choices?.length
+            ? [`pantheon approvals answer ${i.id} ${i.choices.map((c) => `"${c.answer}"`).join(" | ")}${team}`]
+            : [`pantheon approvals answer ${i.id} "<your answer>"${team}`];
+        out.push(`pantheon explain ${i.id}    (open it in your agent)`);
+        return out;
+    }
+    if (!i.ref)
+        return [];
+    if (i.kind === "owed")
+        return [`pantheon say ANSWER "<your reply>" --ref ${i.ref}${sp}`, `pantheon show ${i.ref}${sp}`];
+    return [`pantheon say NOTE "<your note>" --ref ${i.ref}${sp}`, `pantheon show ${i.ref}${sp}`];
+}
+export function renderWatch(s, o = { now: Date.now() }) {
+    const width = Math.max(40, o.width ?? 100);
+    const c = (code, t) => (o.color ? `\x1b[${code}m${t}\x1b[0m` : t);
+    const B = (t) => c("1", t), D = (t) => c("2", t), Y = (t) => c("33", t);
+    const fit = (t, n = width) => (t.length > n ? `${t.slice(0, n - 1)}…` : t);
+    const lines = [];
+    const stamp = new Date(o.now).toLocaleTimeString();
+    if (!s.configured) {
+        lines.push(B("Pantheon board"), "", "This machine is not signed in to a team.", "", D("  pantheon start              start a team"), D("  pantheon join <invite>      join one"));
+        return lines.join("\n") + "\n";
+    }
+    const spaces = s.spaces ?? (s.space ? [s.space] : []);
+    const multi = spaces.length > 1;
+    lines.push(fit(`${B("Pantheon board")}  ${termSafe(s.member ?? "")} · ${termSafe(multi ? `${spaces.length} teams` : (s.space ?? ""))} · ${s.relay_ok ? `${s.online ?? 0} of ${s.members ?? 0} online` : "relay unreachable"} · worker ${s.worker_running ? "running" : "off"}`, width + (o.color ? 8 : 0)));
+    if (s.relay_ok === false || s.decisions_ok === false)
+        lines.push(Y(fit(`! Could not reach: ${termSafe((s.unavailable_spaces ?? []).join(", ") || "the relay")} — what is shown may be incomplete`)));
+    const items = s.items ?? [];
+    for (const lane of LANES) {
+        const mine = items.filter((i) => i.lane === lane.id);
+        lines.push("", B(`${lane.title} (${mine.length})`));
+        if (!mine.length) {
+            lines.push(D(`  ${lane.empty}`));
+            continue;
+        }
+        for (const i of mine) {
+            const meta = [termSafe(i.who), ago(i.when, o.now), multi && i.space ? `team ${termSafe(i.space)}` : ""].filter(Boolean).join(" · ");
+            lines.push(fit(`  • ${termSafe(i.headline || i.title)}`));
+            lines.push(D(fit(`    ${meta}  ${i.id}`)));
+            if (i.context)
+                lines.push(D(fit(`    for: ${termSafe(i.context)}`)));
+            if (lane.id === "now")
+                for (const cmd of watchCommands({ ...i, ...(i.space ? { space: termSafe(i.space) } : {}) }, multi))
+                    lines.push(`    ${cmd}`);
+        }
+    }
+    lines.push("", D(fit(`updated ${stamp} · refreshes every ${BOARD_REFRESH_MS / 1000}s · r refresh · q quit · the board in a browser: pantheon board`)));
+    return lines.join("\n") + "\n";
+}
+export async function watchBoard(o = {}) {
+    const status = o.status ?? (async () => (await import("./tray.js")).trayStatus());
+    const out = o.out ?? process.stdout;
+    const input = o.input ?? process.stdin;
+    const color = !!out.isTTY && !process.env.NO_COLOR;
+    const frame = async () => {
+        let text;
+        try {
+            text = renderWatch(await status(), { now: Date.now(), width: (out.columns ?? 100) - 1, color });
+        }
+        catch (e) {
+            text = `Pantheon board\n\ncould not read the board: ${termSafe(e.message)}\n`;
+        }
+        return text;
+    };
+    if (!out.isTTY) {
+        out.write(await frame());
+        return;
+    }
+    let stopped = false;
+    let timer = null;
+    const draw = async () => {
+        const text = await frame();
+        if (stopped)
+            return;
+        out.write(`\x1b[H${text.replace(/\n/g, "\x1b[K\n")}\x1b[J`);
+    };
+    out.write("\x1b[?25l\x1b[2J");
+    await new Promise((resolveDone) => {
+        const finish = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            if (timer)
+                clearInterval(timer);
+            if (input.isTTY) {
+                try {
+                    input.setRawMode(false);
+                }
+                catch { }
+                input.pause();
+            }
+            out.write("\x1b[?25h\n");
+            resolveDone();
+        };
+        if (input.isTTY) {
+            input.setRawMode(true);
+            input.resume();
+            input.on("data", (d) => {
+                const k = d.toString();
+                if (k === "q" || k === "Q" || k === "\u0003" || k === "\u001b")
+                    finish();
+                else if (k === "r" || k === "R")
+                    void draw();
+            });
+        }
+        process.once("SIGINT", finish);
+        process.once("SIGTERM", finish);
+        void draw();
+        timer = setInterval(() => { void draw(); }, BOARD_REFRESH_MS);
+    });
+}
+export function boardHtml(nonce) {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<meta name="color-scheme" content="light dark">
+<title>Pantheon board</title>
+<link rel="icon" href="data:,">
+<style nonce="${nonce}">${BOARD_CSS}</style>
+</head>
+<body>
+<a class="skip" href="#board">Skip to the board</a>
+<header class="top">
+  <div class="title"><h1>Pantheon</h1><p id="who" class="muted"></p></div>
+  <div class="bar"><span id="health" class="muted"></span><button type="button" id="refresh">Refresh</button></div>
+</header>
+<div id="banner" class="banner" role="alert" hidden></div>
+<main id="board" tabindex="-1" aria-busy="true">
+  <p id="loading" class="muted">Loading your board…</p>
+${LANES.map((l) => `  <section class="lane lane-${l.id}" aria-labelledby="h-${l.id}">
+    <h2 id="h-${l.id}">${l.title} <span class="count" id="c-${l.id}"></span></h2>
+    <ul id="l-${l.id}" class="${l.id === "now" ? "cards" : "rows"}"></ul>
+    <p id="e-${l.id}" class="empty muted" hidden>${l.empty}</p>
+  </section>`).join("\n")}
+</main>
+<dialog id="detail" aria-labelledby="d-title">
+  <div class="dlg">
+    <div class="dlg-head"><h2 id="d-title"></h2><button type="button" id="d-close" aria-label="Close">Close</button></div>
+    <p id="d-meta" class="muted"></p>
+    <p id="d-owner" class="owner"></p>
+    <p id="d-context" class="muted" hidden></p>
+    <div id="d-body" class="body"></div>
+    <div id="d-options" class="choices" role="group" aria-label="Answer with one of its options" hidden></div>
+    <div id="d-choices" class="choices" role="group" aria-label="One-click answers" hidden></div>
+    <div class="reply">
+      <label for="d-kind">Reply as</label>
+      <select id="d-kind"></select>
+      <label for="d-text" class="sr">Your words</label>
+      <textarea id="d-text" rows="4" placeholder="Your own words. Nothing is sent until you press Send."></textarea>
+      <div class="row"><button type="button" id="d-send" class="primary">Send</button><span class="muted hint">Ctrl+Enter sends</span></div>
+    </div>
+    <p id="d-status" role="status" aria-live="polite"></p>
+    <div class="row"><button type="button" id="d-retract" hidden>Retract what I sent</button></div>
+    <div class="row actions" id="d-actions"></div>
+    <section id="d-thread" class="thread" hidden aria-label="The thread"></section>
+  </div>
+</dialog>
+<p id="toast" class="toast" role="status" aria-live="polite"></p>
+<script nonce="${nonce}">${BOARD_JS}</script>
+</body>
+</html>
+`;
+}
+const BOARD_CSS = `
+:root{--bg:#f7f7f5;--card:#fff;--text:#1b1b1b;--muted:#545454;--line:#d6d6d2;--accent:#0b57d0;--accent-text:#fff;--warn-bg:#fff4d6;--warn-text:#4d3800;--err-bg:#fde7e7;--err-text:#6b0f0f;--focus:#0b57d0;--chip:#ececea}
+@media (prefers-color-scheme:dark){:root{--bg:#121212;--card:#1d1d1d;--text:#ececec;--muted:#b0b0b0;--line:#3a3a3a;--accent:#8ab4f8;--accent-text:#0b1a33;--warn-bg:#3a2f0b;--warn-text:#ffe7a3;--err-bg:#3d1414;--err-text:#ffd0d0;--focus:#8ab4f8;--chip:#2a2a2a}}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--text);font:15px/1.45 system-ui,-apple-system,"Segoe UI",Roboto,Ubuntu,Cantarell,"Noto Sans",sans-serif}
+.skip{position:absolute;left:-999px;top:0;background:var(--card);color:var(--text);padding:8px}
+.skip:focus{left:8px}
+.top{display:flex;flex-wrap:wrap;gap:8px 16px;align-items:center;justify-content:space-between;padding:16px 20px;border-bottom:1px solid var(--line)}
+.top h1{font-size:20px;margin:0}
+.title p{margin:2px 0 0}
+.bar{display:flex;gap:12px;align-items:center}
+.muted{color:var(--muted)}
+main{max-width:980px;margin:0 auto;padding:12px 16px 48px}
+main:focus{outline:none}
+.lane h2{font-size:16px;margin:24px 0 8px}
+.count{color:var(--muted);font-weight:400}
+ul{list-style:none;margin:0;padding:0}
+.cards>li{background:var(--card);border:1px solid var(--line);border-radius:10px;padding:14px 16px;margin:0 0 10px}
+.rows>li{border-bottom:1px solid var(--line);padding:8px 2px}
+h3{font-size:15px;margin:0 0 4px;font-weight:600}
+.linkish{all:unset;cursor:pointer;color:var(--text);overflow-wrap:anywhere}
+.linkish:hover{text-decoration:underline}
+.linkish:focus-visible,button:focus-visible,select:focus-visible,textarea:focus-visible,a:focus-visible{outline:3px solid var(--focus);outline-offset:2px}
+.meta{margin:0;font-size:13px;color:var(--muted)}
+.chip{display:inline-block;background:var(--chip);border-radius:6px;padding:0 6px;margin-left:4px;font-size:12px;color:var(--text)}
+.ctx{margin:4px 0 0;font-size:13px;color:var(--muted)}
+.actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:10px}
+.choices{display:flex;flex-wrap:wrap;gap:8px;margin:10px 0}
+button{font:inherit;font-size:14px;padding:6px 12px;border-radius:8px;border:1px solid var(--line);background:var(--card);color:var(--text);cursor:pointer}
+button:hover{border-color:var(--muted)}
+button[disabled]{opacity:.55;cursor:default}
+.primary{background:var(--accent);border-color:var(--accent);color:var(--accent-text)}
+.banner{max-width:980px;margin:12px auto 0;padding:10px 14px;border-radius:8px;background:var(--warn-bg);color:var(--warn-text)}
+.banner.err{background:var(--err-bg);color:var(--err-text)}
+.empty{margin:4px 0}
+dialog{border:1px solid var(--line);border-radius:12px;padding:0;background:var(--card);color:var(--text);width:min(760px,96vw);max-height:92vh}
+dialog::backdrop{background:rgba(0,0,0,.45)}
+.dlg{padding:18px 20px}
+.dlg-head{display:flex;gap:12px;align-items:flex-start;justify-content:space-between}
+.dlg-head h2{font-size:18px;margin:0;overflow-wrap:anywhere}
+.owner{font-weight:600;margin:8px 0}
+.body p{margin:8px 0;white-space:pre-wrap;overflow-wrap:anywhere}
+.body ul{list-style:disc;padding-left:22px}
+pre{background:var(--chip);padding:8px 10px;border-radius:6px;overflow:auto;white-space:pre-wrap;overflow-wrap:anywhere}
+.reply{display:grid;gap:6px;margin:12px 0;border-top:1px solid var(--line);padding-top:12px}
+.reply select{justify-self:start}
+select,textarea{font:inherit;color:var(--text);background:var(--bg);border:1px solid var(--line);border-radius:8px;padding:6px 8px}
+textarea{width:100%;resize:vertical}
+.row{display:flex;gap:10px;align-items:center;flex-wrap:wrap}
+.hint{font-size:12px}
+.sr{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0)}
+.thread{border-top:1px solid var(--line);margin-top:12px;padding-top:8px}
+.thread article{border-bottom:1px solid var(--line);padding:8px 0}
+.thread .body-text{white-space:pre-wrap;overflow-wrap:anywhere;margin:4px 0 0}
+.toast{position:fixed;left:50%;bottom:16px;transform:translateX(-50%);background:var(--text);color:var(--bg);padding:8px 14px;border-radius:8px;margin:0;max-width:90vw}
+.toast:empty{display:none}
+.copybox{width:100%;margin-top:8px}
+`;
+const BOARD_JS = `
+(() => {
+"use strict";
+const $ = (id) => document.getElementById(id);
+const LANES = ${JSON.stringify(LANES.map((l) => l.id))};
+// The link's single-use nonce, traded once for a session secret. The secret
+// lives in sessionStorage (this exact origin, port included) and goes out only
+// as a header this page sets — never as a cookie, which the browser would also
+// send to every other port on 127.0.0.1.
+const SESSION_KEY = "pantheon-board-session";
+let link = null;
+let session = null;
+{
+  const m = /^#open=([0-9a-f]{64})$/.exec(location.hash);
+  if (m) link = m[1];
+  // The nonce leaves the address bar and this history entry before anything else runs.
+  history.replaceState(null, "", "/");
+}
+try { const s = sessionStorage.getItem(SESSION_KEY); if (s && /^[0-9a-f]{64}$/.test(s)) session = s; } catch { /* storage off: this tab only */ }
+function keepSession(s) { session = s; try { if (s) sessionStorage.setItem(SESSION_KEY, s); else sessionStorage.removeItem(SESSION_KEY); } catch { /* storage off */ } }
+let state = null;
+let current = null;
+let lastSent = null;
+let retractTimer = null;
+let timer = null;
+let refreshMs = ${BOARD_REFRESH_MS};
+
+function el(tag, cls, text) {
+  const e = document.createElement(tag);
+  if (cls) e.className = cls;
+  if (text !== undefined && text !== null) e.textContent = String(text);
+  return e;
+}
+function button(label, onClick, cls) {
+  const b = el("button", cls || "", label);
+  b.type = "button";
+  b.addEventListener("click", onClick);
+  return b;
+}
+function ago(ms) {
+  if (!ms) return "";
+  const s = Math.max(0, Math.round((Date.now() - ms) / 1000));
+  if (s < 60) return "just now";
+  const m = Math.round(s / 60); if (m < 60) return m + "m ago";
+  const h = Math.round(m / 60); if (h < 48) return h + "h ago";
+  return Math.round(h / 24) + "d ago";
+}
+let toastTimer = null;
+function toast(msg) {
+  $("toast").textContent = msg;
+  if (toastTimer) clearTimeout(toastTimer);
+  toastTimer = setTimeout(() => { $("toast").textContent = ""; }, 6000);
+}
+function banner(msg, isError) {
+  const b = $("banner");
+  if (!msg) { b.hidden = true; b.textContent = ""; return; }
+  // The same words again are not news: an alert re-announced every refresh is noise.
+  if (!b.hidden && b.textContent === msg) return;
+  b.textContent = msg;
+  b.className = isError ? "banner err" : "banner";
+  b.hidden = false;
+}
+
+async function api(path, body, bearer) {
+  const headers = { "Accept": "application/json" };
+  const cred = bearer || session;
+  if (cred) headers["Authorization"] = "Bearer " + cred;
+  const init = { method: body === undefined ? "GET" : "POST", headers, credentials: "omit", cache: "no-store", redirect: "error" };
+  if (body !== undefined) { headers["Content-Type"] = "application/json"; init.body = JSON.stringify(body); }
+  let res;
+  try { res = await fetch(path, init); }
+  catch { const e = new Error("gone"); e.gone = true; throw e; }
+  let j = null;
+  try { j = await res.json(); } catch { j = null; }
+  if (res.status === 401) { const e = new Error("auth"); e.auth = true; throw e; }
+  if (!res.ok) throw new Error((j && j.error) || ("the board answered " + res.status));
+  return j;
+}
+
+function multi() { return !!(state && state.spaces && state.spaces.length > 1); }
+function surface() { return (state && state.surface_name) || "your agent"; }
+function key(item) { return (item.space || "") + "|" + item.id; }
+
+function render() {
+  const s = state;
+  $("loading").hidden = true;
+  $("board").setAttribute("aria-busy", "false");
+  if (!s.configured) {
+    $("who").textContent = "";
+    $("health").textContent = "";
+    banner("This machine is not signed in to a team. Run pantheon start to start one, or pantheon join with your invite.", true);
+    for (const l of LANES) { $("l-" + l).replaceChildren(); $("c-" + l).textContent = ""; $("e-" + l).hidden = false; }
+    return;
+  }
+  const spaces = s.spaces || (s.space ? [s.space] : []);
+  $("who").textContent = (s.member || "") + " · " + (spaces.length > 1 ? spaces.length + " teams: " + spaces.join(", ") : "team " + (s.space || ""));
+  $("health").textContent = (s.relay_ok ? (s.online || 0) + " of " + (s.members || 0) + " online" : "relay unreachable") + " · worker " + (s.worker_running ? "running" : "off") + (s.worker_state ? " (" + s.worker_state + ")" : "");
+  const down = (s.unavailable_spaces || []);
+  const items = s.items || [];
+  if (!s.relay_ok && !items.length) banner("The relay could not be reached" + (down.length ? " for " + down.join(", ") : "") + ". The board will try again in " + Math.round(refreshMs / 1000) + " seconds.", true);
+  else if (down.length || s.decisions_ok === false) banner("Could not reach: " + (down.join(", ") || "the relay") + ". What is shown may be incomplete.", false);
+  else banner("");
+  // Keep the keyboard where it was across a redraw.
+  const f = document.activeElement;
+  const keep = f && f.dataset ? { k: f.dataset.k, a: f.dataset.a } : null;
+  for (const lane of LANES) {
+    const list = $("l-" + lane);
+    const mine = items.filter((i) => i.lane === lane);
+    $("c-" + lane).textContent = "(" + mine.length + ")";
+    $("e-" + lane).hidden = mine.length > 0;
+    list.replaceChildren(...mine.map((i) => row(i, lane === "now")));
+  }
+  if (keep && keep.k) {
+    for (const b of document.querySelectorAll("[data-k]")) if (b.dataset.k === keep.k && b.dataset.a === keep.a) { b.focus(); break; }
+  }
+}
+
+function tag(b, item, a) { b.dataset.k = key(item); b.dataset.a = a; return b; }
+
+function row(item, card) {
+  const li = el("li");
+  const h = el("h3");
+  h.append(tag(button(item.headline || item.title, () => openDetail(item), "linkish"), item, "open"));
+  li.append(h);
+  const meta = el("p", "meta");
+  meta.append(el("span", "", [item.who, ago(item.when)].filter(Boolean).join(" · ")));
+  if (multi() && item.space) meta.append(el("span", "chip", item.space));
+  if (item.kind === "decision") meta.append(el("span", "chip", "your decision"));
+  else if (item.kind === "owed") meta.append(el("span", "chip", item.promise ? "your agent promised" : "your side owes"));
+  else meta.append(el("span", "chip", item.decider ? item.decider + " decides" : "waiting on " + item.who));
+  li.append(meta);
+  if (item.context) li.append(el("p", "ctx", "For: " + item.context));
+  const acts = el("div", "actions");
+  if (card) {
+    (item.choices || []).forEach((c, idx) => acts.append(tag(button(c.label, (ev) => act({ op: "choose", id: item.id, space: item.space, index: idx }, ev.currentTarget, c.label + " — sent."), idx === 0 ? "primary" : ""), item, "c" + idx)));
+    if (item.kind === "decision") acts.append(tag(button("Mark done", (ev) => act({ op: "done", id: item.id, space: item.space }, ev.currentTarget), ""), item, "done"));
+    acts.append(tag(button("Reply…", () => openDetail(item, true)), item, "reply"));
+    acts.append(tag(button("Explain in " + surface(), (ev) => act({ op: "open", id: item.id, space: item.space }, ev.currentTarget)), item, "explain"));
+  } else {
+    acts.append(tag(button("Details", () => openDetail(item)), item, "details"));
+  }
+  acts.append(tag(button("Copy the question", () => copy(item.prompt)), item, "copy"));
+  li.append(acts);
+  return li;
+}
+
+async function copy(text) {
+  try { await navigator.clipboard.writeText(text); toast("Copied — paste it into your agent."); return; }
+  catch { /* fall back to a box the person copies from */ }
+  const box = el("textarea", "copybox");
+  box.readOnly = true;
+  box.value = text;
+  box.setAttribute("aria-label", "The question, to copy");
+  const host = $("detail").open ? $("d-status") : $("banner");
+  host.replaceChildren(box);
+  host.hidden = false;
+  box.focus(); box.select();
+  toast("Press Ctrl+C (or Cmd+C) to copy.");
+}
+
+async function act(body, btn, okText) {
+  if (btn) btn.disabled = true;
+  toast("Working…");
+  try {
+    const r = await api("/api/action", body);
+    toast(r.ok ? (okText || r.message) : "Not sent — " + r.message);
+    if (r.ok) await refresh();
+    return r;
+  } catch (e) {
+    toast(e.auth ? "This board link has expired. Run pantheon board to open a fresh one." : e.gone ? "The board has stopped. Run pantheon board to start it again." : "Not sent — " + e.message);
+    return null;
+  } finally { if (btn) btn.disabled = false; }
+}
+
+function ownerLine(item) {
+  if (item.kind === "decision") return "Yours to decide.";
+  if (item.decider) return item.decider + "'s to decide. You can add a note or ask back.";
+  if (item.kind === "owed") return "Your agent owes this. You can add a note or ask back.";
+  return "Waiting on " + item.who + ". You can add a note or ask back.";
+}
+
+function blocks(host, list) {
+  host.replaceChildren();
+  for (const b of list) {
+    if (b.kind === "para") host.append(el("p", "", b.text));
+    else if (b.kind === "bullets") { const ul = el("ul"); for (const t of b.items || []) ul.append(el("li", "", t)); host.append(ul); }
+    else if (b.kind === "code") { const pre = el("pre"); pre.append(el("code", "", (b.lines || []).join("\\n"))); host.append(pre); }
+  }
+}
+
+function setStatus(msg) { $("d-status").replaceChildren(); $("d-status").textContent = msg || ""; }
+
+async function openDetail(item, focusReply) {
+  current = item;
+  const d = $("detail");
+  $("d-title").textContent = item.headline || item.title;
+  $("d-meta").textContent = [item.who, ago(item.when), item.space ? "team " + item.space : ""].filter(Boolean).join(" · ");
+  $("d-owner").textContent = ownerLine(item);
+  $("d-context").hidden = !item.context;
+  $("d-context").textContent = item.context ? "For: " + item.context : "";
+  blocks($("d-body"), [{ kind: "para", text: item.detail || "" }]);
+  $("d-options").hidden = true; $("d-options").replaceChildren();
+  const ch = $("d-choices"); ch.replaceChildren();
+  (item.choices || []).forEach((c, idx) => ch.append(button(c.label, (ev) => act({ op: "choose", id: item.id, space: item.space, index: idx }, ev.currentTarget, c.label + " — sent.").then((r) => { if (r && r.ok) d.close(); }), idx === 0 ? "primary" : "")));
+  ch.hidden = !(item.choices && item.choices.length);
+  const kind = $("d-kind"); kind.replaceChildren();
+  for (const [v, label] of (item.kind === "decision" ? [["ANSWER", "Answer"], ["NOTE", "Note"], ["ASK", "Ask back"]] : [["NOTE", "Note"], ["ASK", "Ask back"]])) { const o = el("option", "", label); o.value = v; kind.append(o); }
+  $("d-text").value = "";
+  setStatus("");
+  $("d-retract").hidden = true;
+  const actions = $("d-actions"); actions.replaceChildren();
+  if (item.kind === "decision") actions.append(button("Mark done", (ev) => act({ op: "done", id: item.id, space: item.space }, ev.currentTarget).then((r) => { if (r && r.ok) d.close(); })));
+  actions.append(button("Explain in " + surface(), (ev) => act({ op: "open", id: item.id, space: item.space }, ev.currentTarget)));
+  if (item.goal && item.space) actions.append(button("Show the thread", () => thread(item)));
+  actions.append(button("Copy the question", () => copy(item.prompt)));
+  $("d-thread").hidden = true; $("d-thread").replaceChildren();
+  if (!d.open) d.showModal();
+  if (focusReply) $("d-text").focus(); else $("d-close").focus();
+  if (!item.ref) return;
+  try {
+    const q = "/api/detail?id=" + encodeURIComponent(item.ref) + (item.space ? "&space=" + encodeURIComponent(item.space) : "");
+    const j = await api(q);
+    if (current !== item || !j || !j.ok) return;
+    if (Array.isArray(j.blocks) && j.blocks.length) blocks($("d-body"), j.blocks);
+    if (item.kind === "decision" && Array.isArray(j.options) && j.options.length) {
+      const host = $("d-options");
+      for (const o of j.options) host.append(button("(" + o.key + ") " + o.text, (ev) => act({ op: "reply", id: item.id, space: item.space, kind: "ANSWER", body: "(" + o.key + ") " + o.text }, ev.currentTarget, "Answered (" + o.key + ") — it is no longer waiting on you.").then((r) => { if (r && r.ok) d.close(); })));
+      host.hidden = false;
+    }
+  } catch { /* the short text stays */ }
+}
+
+async function thread(item) {
+  const host = $("d-thread");
+  host.hidden = false;
+  host.replaceChildren(el("p", "muted", "Loading the thread…"));
+  try {
+    const j = await api("/api/thread?goal=" + encodeURIComponent(item.goal) + "&space=" + encodeURIComponent(item.space));
+    host.replaceChildren(el("h3", "", "The thread"));
+    if (!j.ok || !j.acts.length) { host.append(el("p", "muted", j.ok ? "Nothing in this thread yet." : j.error)); return; }
+    for (const a of j.acts) {
+      const art = el("article");
+      art.append(el("p", "meta", [a.from, a.act, ago(a.ts)].filter(Boolean).join(" · ")));
+      art.append(el("p", "body-text", a.summary && a.body.length > 600 ? a.summary : a.body));
+      host.append(art);
+    }
+  } catch (e) { host.replaceChildren(el("p", "muted", "The thread could not be read: " + e.message)); }
+}
+
+async function send() {
+  const item = current;
+  if (!item) return;
+  const text = $("d-text").value.trim();
+  if (!text) { setStatus("Type your reply first."); return; }
+  const kind = $("d-kind").value;
+  const btn = $("d-send");
+  if (btn.disabled) return;
+  btn.disabled = true;
+  setStatus("Sending…");
+  try {
+    const r = await api("/api/action", { op: "reply", id: item.id, space: item.space, kind, body: text });
+    if (!r.ok) { setStatus("Not sent — " + r.message + " Your words are still in the box."); return; }
+    $("d-text").value = "";
+    setStatus(kind === "ANSWER" ? "Answered — it is no longer waiting on you." : kind === "ASK" ? "Asked — the agent that raised this owes you a reply." : "Noted — it stays waiting.");
+    if (r.sent) {
+      lastSent = r.sent;
+      $("d-retract").hidden = false;
+      if (retractTimer) clearTimeout(retractTimer);
+      retractTimer = setTimeout(() => { $("d-retract").hidden = true; lastSent = null; }, 60000);
+    }
+    refresh();
+  } catch (e) {
+    setStatus(e.auth ? "This board link has expired. Run pantheon board to open a fresh one." : "Not sent — " + (e.gone ? "the board has stopped." : e.message) + " Your words are still in the box.");
+  } finally { btn.disabled = false; }
+}
+
+async function retract() {
+  if (!lastSent) return;
+  const btn = $("d-retract");
+  btn.disabled = true;
+  setStatus("Retracting…");
+  try {
+    const r = await api("/api/action", { op: "retract", act: lastSent });
+    if (r.ok) { lastSent = null; btn.hidden = true; setStatus("Retracted."); refresh(); }
+    else setStatus("Could not retract — " + (r.message || r.error));
+  } catch (e) { setStatus("Could not retract — " + e.message); }
+  finally { btn.disabled = false; }
+}
+
+async function refresh() {
+  try {
+    const j = await api("/api/board");
+    if (!j.ok) { banner(j.error || "The board could not be read.", true); return; }
+    if (j.refresh_ms) refreshMs = j.refresh_ms;
+    state = j.status;
+    render();
+    $("refresh").title = "Updated " + new Date(j.at).toLocaleTimeString();
+  } catch (e) {
+    $("loading").hidden = true;
+    if (e.auth) { keepSession(null); banner("This board link has expired. Run pantheon board to open a fresh one.", true); stop(); }
+    else if (e.gone) { banner("The board has stopped — it stops after 30 minutes with no open tab. Run pantheon board to start it again.", true); stop(); }
+    else banner("The board could not be read: " + e.message, true);
+  }
+}
+function stop() { if (timer) { clearInterval(timer); timer = null; } }
+function schedule() { stop(); if (!document.hidden) timer = setInterval(refresh, refreshMs); }
+
+$("refresh").addEventListener("click", () => refresh());
+$("d-close").addEventListener("click", () => $("detail").close());
+$("detail").addEventListener("close", () => { current = null; });
+$("d-send").addEventListener("click", () => send());
+$("d-retract").addEventListener("click", () => retract());
+$("d-text").addEventListener("keydown", (ev) => { if (ev.key === "Enter" && (ev.ctrlKey || ev.metaKey)) { ev.preventDefault(); send(); } });
+// A hidden tab stops asking: the relay is not polled for nobody, and the board
+// can stop itself once no one is looking.
+document.addEventListener("visibilitychange", () => { if (!document.hidden) refresh(); schedule(); });
+
+(async () => {
+  if (link) {
+    const once = link;
+    link = null;
+    try {
+      const j = await api("/api/session", {}, once);
+      if (!j || typeof j.session !== "string" || !/^[0-9a-f]{64}$/.test(j.session)) throw new Error("no session");
+      keepSession(j.session);
+    } catch (e) {
+      // A used or expired link, but this tab already has a session: carry on with it.
+      if (!(e.auth && session)) { $("loading").hidden = true; banner(e.auth ? "This board link has expired or was already used. Run pantheon board to open a fresh one." : "The board could not be reached. Run pantheon board again.", true); return; }
+    }
+  }
+  if (!session) { $("loading").hidden = true; banner("This board needs its link. Run pantheon board to open it.", true); return; }
+  await refresh();
+  schedule();
+})();
+})();
+`;
+//# sourceMappingURL=board.js.map