@join-pantheon/cli 0.24.1 → 0.24.4

package/dist/cli.js

@@ -331,6 +331,42 @@ async function fetchHistory(cfg, since = 0) {
         throw new Error(`relay answered ${res.status} for the ledger`);
     return (await res.json()).acts ?? [];
 }
+async function fetchAct(cfg, id) {
+    const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
+    const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
+    try {
+        const res = await fetch(`${base}/act?${q}&id=${encodeURIComponent(id)}`, { signal: AbortSignal.timeout(8000) });
+        if (res.ok) {
+            const body = await res.json();
+            if (body.act)
+                return { act: body.act, ...(body.goal?.title ? { goalTitle: body.goal.title } : {}) };
+        }
+        if (res.status === 404) {
+        }
+    }
+    catch { }
+    let head = 0;
+    try {
+        const h = await (await fetch(`${base}/health?space=${encodeURIComponent(cfg.space)}`, { signal: AbortSignal.timeout(8000) })).json();
+        head = h.spaces?.[0]?.seq ?? 0;
+    }
+    catch { }
+    const windows = head > 0 ? [60, 200, 600].map((n) => Math.max(0, head - n)) : [0];
+    if (windows[windows.length - 1] !== 0)
+        windows.push(0);
+    for (const since of windows) {
+        try {
+            const acts = await fetchHistory(cfg, since);
+            const act = acts.find((a) => a.id === id || String(a.seq) === id);
+            if (act)
+                return { act };
+            if (since === 0)
+                return null;
+        }
+        catch { }
+    }
+    return null;
+}
 function workerMidRun() {
     try {
         const s = JSON.parse(readFileSync(join(CONFIG_DIR, "worker-state.json"), "utf8"));
@@ -2165,6 +2201,21 @@ async function main() {
                     hud = null;
                 }
             }
+            if (hud?.action === "done") {
+                const c2 = new PantheonClient(cfg, undefined, { role: "cli" });
+                await c2.connect().catch((e) => die(e.message));
+                const o = hud.decision ? c2.obligations.find((x) => x.id === hud.decision) : undefined;
+                if (!o) {
+                    c2.close();
+                    console.error(D("that decision is no longer waiting on you"));
+                    return;
+                }
+                await c2.send({ act: "ANSWER", ref: o.ref, goal: o.goal, after_seq: c2.readSeq,
+                    body: "Marked done from the alert — handled outside this thread." }).catch((e) => die(e.message));
+                c2.close();
+                console.error(D(`done — ${o.id} is no longer waiting on you`));
+                return;
+            }
             if (hud?.action === "details") {
                 const acts = await fetchHistory(cfg).catch(() => []);
                 const a = hud.act ? acts.find((x) => x.id === hud.act) : undefined;
@@ -2460,6 +2511,31 @@ async function main() {
             console.log(JSON.stringify(await trayStatus()));
             return;
         }
+        case "tray-detail": {
+            const key = argv[1] ?? die("usage: pantheon tray-detail <act id>");
+            const cfgNow = load() ?? die("not joined to a team");
+            const { humanize } = await import("./humanize.js");
+            const found = await fetchAct(cfgNow, key);
+            if (!found) {
+                console.log(JSON.stringify({ ok: false }));
+                return;
+            }
+            const a = found.act;
+            let goalTitle = found.goalTitle;
+            if (!goalTitle && a.goal) {
+                const c2 = new PantheonClient(cfgNow, undefined, { role: "cli" });
+                goalTitle = await c2.connect().then(() => c2.goals.get(a.goal)?.title).catch(() => undefined);
+                c2.close();
+            }
+            const { headline, blocks } = humanize(a.body, { ...(goalTitle ? { goalTitle } : {}), from: a.from });
+            console.log(JSON.stringify({
+                ok: true, id: a.id, act: a.act, from: a.from, ts: a.ts,
+                ...(a.summary ? { summary: a.summary } : {}),
+                ...(goalTitle ? { goal_title: goalTitle } : {}),
+                headline, blocks, raw: a.body,
+            }));
+            return;
+        }
         case "menubar": {
             need();
             const { ensureTrayBinary, writeTrayCommands } = await import("./tray.js");

package/dist/decision-ui.js

@@ -4,7 +4,14 @@ export function decisionTitle(body, max = 96) {
         .replace(/^[a-z0-9._-]+\s+escalated:\s*/i, "")
         .replace(/^[a-z0-9._-]+\s+needs a decision:\s*/i, "")
         .replace(/^human (?:action|input) required\s*[—:-]\s*/i, "")
-        .replace(/^human (?:action|input) required\s*/i, "");
+        .replace(/^human (?:action|input) required\s*/i, "")
+        .replace(/^needs (?:you|your input|a human)[,:]?\s*[a-z0-9._-]*\s*[:—-]\s*/i, "")
+        .replace(/\(goal\s+g_[a-z0-9]+\s*,\s*/gi, "(")
+        .replace(/\s*\b(?:of|in|for|on|from)?\s*\(?\bgoal\s+g_[a-z0-9]+\)?/gi, "")
+        .replace(/\s{2,}/g, " ")
+        .replace(/[\s,]+(?:of|in|for|on|at|to|from)$/i, "")
+        .replace(/[\s,;:]+$/, "")
+        .trim();
     const blockedAsk = text.match(/^cannot answer (.+?)\s+ask\s*:/i);
     if (blockedAsk) {
         text = `Decide whether to share the information requested for ${blockedAsk[1]}`;
@@ -25,6 +32,12 @@ export function decisionPrompt(id) {
 export function allDecisionsPrompt(count) {
     return `Check my ${count} Pantheon decision${count === 1 ? "" : "s"}. Explain each one in plain language: what happened, why I am needed, my options, and your recommendation. Prioritize what needs attention first. Do not decide or act for me; wait for my answers.`;
 }
+export function owedPrompt(title, goal) {
+    return `Pantheon: my side owes this — "${title}". Read the thread (pantheon history${goal ? ` --goal ${goal}` : ""}), tell me in plain language what is owed, what is already done, and exactly what you would send to discharge it. Draft the act, then wait for me before sending.`;
+}
+export function waitingPrompt(who, title, goal) {
+    return `Pantheon: I am waiting on ${who} for "${title}". Read the thread (pantheon history${goal ? ` --goal ${goal}` : ""}), tell me whether it is genuinely blocked on them, how long it has been waiting, and whether anything on my side is holding it up. If a nudge is warranted, draft a short one and wait for me.`;
+}
 export function workerSummary(raw) {
     const state = oneLine(raw);
     if (/deferring.*turn is in flight|holding.*live session/i.test(state))

package/dist/humanize.js

@@ -0,0 +1,223 @@
+const PARA_CHARS = 340;
+const flatten = (s) => s.replace(/[\u2018\u2019\u201B]/g, "'").replace(/[\u201C\u201D]/g, '"');
+export function stripIds(text, goalTitle) {
+    let out = flatten(text);
+    if (goalTitle) {
+        const esc = flatten(goalTitle).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        out = out.replace(new RegExp(`\\s*\\(\\s*"${esc}"\\s*\\)`, "gi"), "");
+        out = out.replace(new RegExp(`\\s*,?\\s*"${esc}"`, "gi"), "");
+    }
+    return out
+        .replace(/^needs (?:you|your input|a human)[,:]?\s*[a-z0-9._-]*\s*[:—-]\s*/i, "")
+        .replace(/^[a-z0-9._-]+\s+(?:escalated|needs a decision)\s*:\s*/i, "")
+        .replace(/\(\s*goal\s+g_[a-z0-9]+\s*,\s*/gi, "(")
+        .replace(/\s*\(\s*goal\s+g_[a-z0-9]+\s*\)/gi, "")
+        .replace(/\s*\bgoal\s+g_[a-z0-9]+/gi, "")
+        .replace(/\s*\bid=[ao]_[a-z0-9]+/gi, "")
+        .replace(/\(\s*\)/g, "")
+        .replace(/\s+([,.;:])/g, "$1")
+        .replace(/[ \t]{2,}/g, " ")
+        .trim();
+}
+const ABBREV = /\b(?:e\.g|i\.e|vs|etc|approx|no|fig|mr|ms|dr|jr|sr|[a-z])\.$/i;
+export function sentences(text) {
+    const out = [];
+    let buf = "";
+    for (const piece of text.split(/(?<=[.!?])\s+/)) {
+        buf = buf ? `${buf} ${piece}` : piece;
+        if (ABBREV.test(buf.trim()))
+            continue;
+        if (/[.!?]["')\]]?$/.test(buf.trim())) {
+            out.push(buf.trim());
+            buf = "";
+        }
+    }
+    if (buf.trim())
+        out.push(buf.trim());
+    return out;
+}
+const VERBS = /^(?:uname|hostname|echo|ls|cat|grep|tail|head|node|npm|npx|pnpm|yarn|git|gh|pantheon|cowork|xcode-select|launchctl|systemctl|curl|wget|which|ps|kill|pkill|sudo|open|defaults|codesign|swiftc|swift|python3?|pip3?|docker|make|cd|mkdir|rm|cp|mv|chmod|export|brew|sw_vers|scutil|lsof|dig|ping|ssh|scp|awk|sed|sort|uniq|wc|jq|tar|zip|unzip|env|printenv|type|command)\b/;
+const PROSE_WORDS = /\s(?:the|a|an|is|are|was|were|be|been|and|or|to|of|that|this|with|from|into|please|it|its|our|your|their|her|his|for|but|so|then|when|while|which|who|what|why|how|should|would|could|will|can|may|must|has|have|had|does|did|say|says|said|asks?|needs?|wants?)\s/i;
+export function commandLike(segment) {
+    const t = segment.trim().replace(/[.,]$/, "").trim();
+    if (!t || t.length > 160)
+        return false;
+    if (PROSE_WORDS.test(` ${t} `))
+        return false;
+    const first = t.split(/\s+/)[0] ?? "";
+    if (!/^[a-z[$][\w.[\]$-]*$/.test(first))
+        return false;
+    const words = t.split(/\s+/).length;
+    return VERBS.test(t) || /\s-{1,2}[\w-]|[~/]|\||&&|\$\(|^\[/.test(t) || words <= 2;
+}
+function splitLeadIn(segment) {
+    const marks = [...segment.matchAll(/[:,]\s+/g)];
+    for (let i = marks.length - 1; i >= 0; i--) {
+        const at = (marks[i].index ?? 0) + marks[i][0].length;
+        const tail = segment.slice(at);
+        if (commandLike(tail))
+            return { lead: segment.slice(0, at).trim(), cmd: tail.trim() };
+    }
+    return null;
+}
+function asOptions(sentence) {
+    const marks = [...sentence.matchAll(/\((?:[a-z]|[ivx]{1,3})\)\s*/gi)];
+    if (marks.length < 2)
+        return null;
+    const lead = sentence.slice(0, marks[0].index ?? 0).trim().replace(/[,:]$/, "");
+    const items = [];
+    for (let i = 0; i < marks.length; i++) {
+        const from = (marks[i].index ?? 0) + marks[i][0].length;
+        const to = i + 1 < marks.length ? marks[i + 1].index ?? sentence.length : sentence.length;
+        const item = sentence.slice(from, to).trim()
+            .replace(/[,;.]\s*(?:or|and)?\s*$/i, "")
+            .replace(/^(?:or|and)\s+/i, "")
+            .trim();
+        if (item)
+            items.push(item);
+    }
+    return items.length >= 2 ? { lead, items } : null;
+}
+const ITEM = /^(?:[-*•]|\d+[.)])\s+/;
+function asWrittenList(lines) {
+    const at = lines.findIndex((l) => ITEM.test(l));
+    if (at < 0 || lines.length - at < 2)
+        return null;
+    if (!lines.slice(at).every((l) => ITEM.test(l)))
+        return null;
+    return {
+        lead: lines.slice(0, at).join(" ").trim(),
+        items: lines.slice(at).map((l) => l.replace(ITEM, "").trim()),
+    };
+}
+function extractCommands(sentence) {
+    if (!sentence.includes(";"))
+        return null;
+    const parts = sentence.split(";").map((p) => p.trim()).filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    let lead = "";
+    let start = -1;
+    const lines = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (commandLike(part)) {
+            if (start < 0)
+                start = i;
+            lines.push(part.replace(/\.$/, "").trim());
+            continue;
+        }
+        if (start < 0) {
+            const split = splitLeadIn(part);
+            if (split) {
+                lead = [lead, split.lead].filter(Boolean).join(" ");
+                start = i;
+                lines.push(split.cmd);
+                continue;
+            }
+            lead = [lead, part].filter(Boolean).join("; ");
+            continue;
+        }
+        return lines.length >= 2 ? { lead: lead.trim(), lines, tail: parts.slice(i).join("; ").trim() } : null;
+    }
+    return lines.length >= 2 ? { lead: lead.trim(), lines, tail: "" } : null;
+}
+function paragraphs(text) {
+    const parts = sentences(text);
+    const out = [];
+    let buf = "";
+    for (const s of parts) {
+        const next = buf ? `${buf} ${s}` : s;
+        if (next.length > PARA_CHARS && buf) {
+            out.push({ kind: "para", text: buf });
+            buf = s;
+        }
+        else
+            buf = next;
+    }
+    if (buf)
+        out.push({ kind: "para", text: buf });
+    return out;
+}
+const asLeadIn = (text) => text.trim().replace(/[,;]$/, ":").replace(/([^:.!?])$/, "$1:");
+const push = (blocks, text, lead = false) => {
+    let t = text.trim();
+    if (!t)
+        return;
+    if (/^[a-z]/.test(t))
+        t = t[0].toUpperCase() + t.slice(1);
+    if (lead) {
+        blocks.push({ kind: "para", text: asLeadIn(t) });
+        return;
+    }
+    blocks.push(...paragraphs(t));
+};
+export function humanize(body, opts = {}) {
+    const clean = stripIds(body.replace(/\r\n/g, "\n"), opts.goalTitle);
+    const blocks = [];
+    for (const chunk of clean.split(/\n{2,}/)) {
+        const lines = chunk.split("\n").map((l) => l.trim()).filter(Boolean);
+        if (!lines.length)
+            continue;
+        const written = asWrittenList(lines);
+        if (written) {
+            if (written.lead)
+                push(blocks, written.lead, true);
+            blocks.push({ kind: "bullets", items: written.items });
+            continue;
+        }
+        if (lines.length >= 2 && lines.every((l) => commandLike(l))) {
+            blocks.push({ kind: "code", lines });
+            continue;
+        }
+        let pending = "";
+        for (const sentence of sentences(lines.join(" "))) {
+            const options = asOptions(sentence);
+            if (options) {
+                push(blocks, `${pending} ${options.lead}`.trim(), true);
+                pending = "";
+                blocks.push({ kind: "bullets", items: options.items });
+                continue;
+            }
+            const cmds = extractCommands(sentence);
+            if (cmds) {
+                push(blocks, `${pending} ${cmds.lead}`.trim(), true);
+                pending = "";
+                blocks.push({ kind: "code", lines: cmds.lines });
+                if (cmds.tail)
+                    pending = cmds.tail;
+                continue;
+            }
+            pending = pending ? `${pending} ${sentence}` : sentence;
+        }
+        push(blocks, pending);
+    }
+    if (!blocks.length)
+        blocks.push({ kind: "para", text: clean });
+    const firstPara = blocks.find((b) => b.kind === "para");
+    let headline = sentences(firstPara?.text ?? clean)[0] ?? clean;
+    headline = headline
+        .replace(/^needs (?:you|your input|a human)[,:]?\s*[a-z0-9._-]*\s*[:—-]\s*/i, "")
+        .replace(/^[a-z0-9._-]+\s+(?:escalated|needs a decision)\s*:\s*/i, "")
+        .trim();
+    if (headline)
+        headline = headline[0].toUpperCase() + headline.slice(1);
+    headline = headline.replace(/\.$/, "").trim();
+    const full = headline;
+    if (headline.length > 180)
+        headline = `${headline.slice(0, 179).trimEnd()}…`;
+    const first = blocks[0];
+    if (full && first && first.kind === "para") {
+        const [lead, ...rest] = sentences(first.text);
+        const same = (lead ?? "").replace(/\.$/, "").trim().toLowerCase() === full.toLowerCase();
+        if (same) {
+            const remainder = rest.join(" ").trim();
+            if (remainder)
+                blocks[0] = { kind: "para", text: remainder };
+            else
+                blocks.shift();
+        }
+    }
+    return { headline: headline || "Open item", blocks };
+}
+//# sourceMappingURL=humanize.js.map

package/dist/notifier.js

@@ -9,26 +9,37 @@ import { CONFIG_DIR } from "./config.js";
 import { loadProfile } from "./profile.js";
 import { APP_TOOLS, composeDecision, composeDelivery, TOOL_LABELS } from "./notice.js";
 import { cliOnPath, detectAvailable } from "./agents.js";
+import { whichPantheon } from "./service.js";
 export const DEFAULT_REMINDER_MS = 4 * 60 * 60 * 1_000;
+export const MAX_REMINDERS = 4;
+const DAY_MS = 24 * 60 * 60 * 1_000;
 export function humanObligations(obligations, member) {
     return obligations.filter((o) => o.kind === "HUMAN" && o.owner === `human:${member}`);
 }
 export function dueHumanObligations(obligations, member, state, now, reminderMs) {
     return humanObligations(obligations, member).filter((o) => {
         const last = state.notified_at[o.id];
-        return last === undefined || now - last >= reminderMs;
+        if (last === undefined)
+            return true;
+        const n = state.reminded?.[o.id] ?? 0;
+        if (n >= MAX_REMINDERS)
+            return false;
+        const gap = Math.min(reminderMs * 2 ** n, Math.max(reminderMs, DAY_MS));
+        return now - last >= gap;
     });
 }
 export function pruneNotificationState(state, obligations, member, now = Date.now()) {
     const active = new Set(humanObligations(obligations, member).map((o) => o.id));
+    const reminded = Object.fromEntries(Object.entries(state.reminded ?? {}).filter(([id]) => active.has(id)));
     return {
         notified_at: Object.fromEntries(Object.entries(state.notified_at).filter(([id, at]) => active.has(id) || (id.startsWith("act:") && now - at < 7 * 86_400_000))),
+        ...(Object.keys(reminded).length ? { reminded } : {}),
     };
 }
 function readState(file) {
     try {
         const parsed = JSON.parse(readFileSync(file, "utf8"));
-        return { notified_at: parsed.notified_at ?? {} };
+        return { notified_at: parsed.notified_at ?? {}, ...(parsed.reminded ? { reminded: parsed.reminded } : {}) };
     }
     catch {
         return { notified_at: {} };
@@ -111,7 +122,7 @@ export function sendDesktopNotification(notice, home = CONFIG_DIR) {
     if (!existsSync(binary))
         return false;
     try {
-        const child = spawn(binary, ["post", "--json", JSON.stringify({ ...notice, bin_dir: join(home, "bin") })], { detached: true, stdio: "ignore" });
+        const child = spawn(binary, ["post", "--json", JSON.stringify({ ...notice, bin_dir: join(home, "bin"), pantheon: whichPantheon() ?? "pantheon" })], { detached: true, stdio: "ignore" });
         child.unref();
         return true;
     }
@@ -139,7 +150,7 @@ export class HumanNotifier {
         const pollMs = this.opts.pollMs ?? 5_000;
         let state = readState(stateFile);
         this.opts.log(`notifier online as ${this.cfg.member}`);
-        this.opts.log(`  reminders every ${Math.round(this.opts.reminderMs / 60_000)} minutes while unresolved`);
+        this.opts.log(`  reminders after ${Math.round(this.opts.reminderMs / 60_000)} minutes, then doubling to daily, ${MAX_REMINDERS} at most — after that a decision waits on pantheon brief and the menu bar`);
         while (!this.stopped) {
             const pruned = pruneNotificationState(state, client.obligations, this.cfg.member, now());
             let dirty = JSON.stringify(pruned) !== JSON.stringify(state);
@@ -153,13 +164,16 @@ export class HumanNotifier {
             const peerOf = (from) => from ? { member: from, agent: client.roster.find((m) => m.id === from)?.agent } : undefined;
             const withLabel = (n) => this.opts.label ? { ...n, context: n.context ? `${this.opts.label} · ${n.context}` : this.opts.label } : n;
             for (const obligation of due) {
+                const isReminder = state.notified_at[obligation.id] !== undefined;
                 const act = client.seenAct(obligation.ref);
                 const notice = withLabel(composeDecision(obligation, act, obligation.goal ? client.goals.get(obligation.goal) : undefined, peerOf(act?.from), { tools, preferred: preferredTool(profile, tools), now: now() }));
                 const ok = send(notice);
                 if (ok) {
                     state.notified_at[obligation.id] = now();
+                    if (isReminder)
+                        state.reminded = { ...(state.reminded ?? {}), [obligation.id]: (state.reminded?.[obligation.id] ?? 0) + 1 };
                     dirty = true;
-                    this.opts.log(`> notified for ${obligation.id} (${oneLine(obligation.body, 100)})`);
+                    this.opts.log(`> ${isReminder ? `reminder ${state.reminded[obligation.id]}/${MAX_REMINDERS}` : "notified"} for ${obligation.id} (${oneLine(obligation.body, 100)})`);
                 }
                 else {
                     this.opts.log(`! could not show a desktop notification for ${obligation.id}`);

package/dist/relay.js

@@ -263,6 +263,17 @@ export class Relay {
                         : {}),
             });
         }
+        if (url.pathname === "/act") {
+            const space = this.spaces.get(url.searchParams.get("space") ?? "");
+            const token = url.searchParams.get("token") ?? "";
+            if (!space || space.token !== token)
+                return this.json(res, 404, { error: "no such space" });
+            const act = space.ledger.find(url.searchParams.get("id") ?? "");
+            if (!act)
+                return this.json(res, 404, { error: "no such act" });
+            const goal = act.goal ? space.goals.get(act.goal) : undefined;
+            return this.json(res, 200, { act, ...(goal ? { goal: { id: goal.id, title: goal.title, state: goal.state } } : {}) });
+        }
         if (url.pathname === "/history") {
             const space = this.spaces.get(url.searchParams.get("space") ?? "");
             const token = url.searchParams.get("token") ?? "";

package/dist/tray.js

@@ -11,7 +11,7 @@ import { requireDeveloperTools } from "./notifier.js";
 import { plistPath, serviceInstalled, whichPantheon } from "./service.js";
 import { VERSION } from "./version.js";
 import { LIMITS } from "./protocol.js";
-import { allDecisionsPrompt, decisionPrompt, decisionTitle, workerSummary } from "./decision-ui.js";
+import { allDecisionsPrompt, decisionPrompt, decisionTitle, owedPrompt, waitingPrompt, workerSummary } from "./decision-ui.js";
 import { loadProfile, SURFACE_BUNDLE_IDS } from "./profile.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const trayBinaryPath = (home = CONFIG_DIR) => join(home, "bin", "pantheon-tray");
@@ -93,6 +93,9 @@ export async function trayStatus(cfg = load(), f = loadAll()) {
             members: ok.reduce((n, p) => n + (p.members ?? 0), 0),
             decisions: ok.flatMap((p) => (p.decisions ?? []).map((d) => ({ ...d, body: `[${p.space}] ${d.body}` }))),
             decisions_prompt: allDecisionsPrompt(ok.reduce((n, p) => n + (p.decisions?.length ?? 0), 0)),
+            items: ok.flatMap((p) => (p.items ?? []).map((i) => ({ ...i, space: p.space }))),
+            owed_count: ok.reduce((n, p) => n + (p.owed_count ?? 0), 0),
+            waiting_count: ok.reduce((n, p) => n + (p.waiting_count ?? 0), 0),
         };
     }
     return trayStatusOne(cfg);
@@ -104,14 +107,33 @@ async function trayStatusOne(cfg) {
     const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
     const [health, obligations] = await Promise.all([
         getJson(`${base}/health?space=${encodeURIComponent(cfg.space)}`),
-        getJson(`${base}/obligations?${q}&member=${encodeURIComponent(`human:${cfg.member}`)}`),
+        getJson(`${base}/obligations?${q}`),
     ]);
     const space = health
         ?.spaces?.find((s) => s.name === cfg.space);
     const pending = obligations?.obligations;
-    const decisionsOk = Array.isArray(pending) && pending.every((o) => o && typeof o.id === "string" && typeof o.body === "string");
-    const decisions = (decisionsOk ? pending : [])
+    const ok = Array.isArray(pending) && pending.every((o) => o && typeof o.id === "string" && typeof o.body === "string" && typeof o.owner === "string");
+    const all = (ok ? pending : []);
+    const mineHuman = all.filter((o) => o.owner === `human:${cfg.member}`);
+    const decisionsOk = ok;
+    const decisions = mineHuman
         .map((o) => ({ id: o.id, body: decisionTitle(o.body), detail: o.body, prompt: decisionPrompt(o.id) }));
+    const row = (o, kind, who, prompt) => ({
+        id: o.id, kind, title: decisionTitle(o.body), headline: decisionTitle(o.body, 200), detail: o.body, prompt, who,
+        when: o.created_at ?? 0,
+        ...(o.goal ? { goal: o.goal } : {}),
+        ...(o.ref ? { ref: o.ref } : {}),
+    });
+    const owed = all.filter((o) => o.owner === cfg.member);
+    const waiting = all.filter((o) => o.owner !== cfg.member && o.owner !== `human:${cfg.member}`);
+    const items = [
+        ...mineHuman.map((o) => row(o, "decision", "you", decisionPrompt(o.id))),
+        ...owed.map((o) => row(o, "owed", "you", owedPrompt(decisionTitle(o.body), o.goal))),
+        ...waiting.map((o) => {
+            const who = o.owner.replace(/^human:/, "");
+            return row(o, "waiting", who, waitingPrompt(who, decisionTitle(o.body), o.goal));
+        }),
+    ];
     const profile = loadProfile(cfg);
     const surface = profile.agent.primary_surface;
     const surfaceName = surface === "claude-code" ? "Claude" : surface === "cursor" ? "Cursor" : "Codex";
@@ -137,6 +159,9 @@ async function trayStatusOne(cfg) {
         surface_bundle_id: SURFACE_BUNDLE_IDS[surface],
         decisions_prompt: allDecisionsPrompt(decisions.length),
         decisions,
+        items,
+        owed_count: owed.length,
+        waiting_count: waiting.length,
     };
 }
 //# sourceMappingURL=tray.js.map

package/helper/macos/main.swift

@@ -9,6 +9,7 @@
  *                      (the choice becomes the default), through a .command file
  *                      Terminal runs — no automation permission needed
  *   Show details       prints the act and the decision in Terminal
+ *   Done               (decisions) answers it as handled, silently — the reminders stop
  *   Dismiss / ×        closes
  *
  * It owns no state. Everything it needs arrives as one JSON document:
@@ -25,7 +26,7 @@ import AppKit
 let args = CommandLine.arguments
 
 if args.count == 2, args[1] == "version" {
-  print("2")
+  print("3")
   exit(0)
 }
 
@@ -45,6 +46,8 @@ struct Notice: Decodable {
   let details: Details?
   /** where to write the chosen action and which .command files to open — supplied by the CLI */
   let bin_dir: String
+  /** the pantheon CLI to run silently for one-click actions — supplied by the CLI, since this helper has no PATH worth trusting */
+  let pantheon: String?
 }
 
 var notice: Notice
@@ -138,6 +141,23 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     act(["action": "details", "act": notice.details?.act as Any, "decision": notice.details?.decision as Any].compactMapValues { $0 is NSNull ? nil : $0 }, command: "pantheon-details.command")
   }
 
+  /// Done: write the action, run the CLI without a Terminal, close. The CLI answers the decision as handled.
+  @objc func markDone(_ sender: Any?) {
+    guard !notice.bin_dir.isEmpty, let decision = notice.details?.decision else { NSApp.terminate(nil); return }
+    let dir = URL(fileURLWithPath: notice.bin_dir)
+    let payload: [String: Any] = ["action": "done", "decision": decision, "act": notice.details?.act as Any].compactMapValues { $0 is NSNull ? nil : $0 }
+    if let data = try? JSONSerialization.data(withJSONObject: payload) {
+      try? data.write(to: dir.appendingPathComponent(".hud-action.json"), options: .atomic)
+    }
+    let bin = (notice.pantheon?.isEmpty == false) ? notice.pantheon! : "pantheon"
+    let quoted = "'" + bin.replacingOccurrences(of: "'", with: "'\\''") + "'"
+    let p = Process()
+    p.executableURL = URL(fileURLWithPath: "/bin/sh")
+    p.arguments = ["-lc", "\(quoted) explain --queued >/dev/null 2>&1"]   // login shell: PATH with node, as the user's own terminal has
+    try? p.run()
+    NSApp.terminate(nil)
+  }
+
   @objc func legacyOpen(_ sender: Any?) {
     if !legacyPrompt.isEmpty { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(legacyPrompt, forType: .string) }
     if let b = legacyBundle, let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: b) {
@@ -260,6 +280,16 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         constraints += [d.leadingAnchor.constraint(equalTo: pull.trailingAnchor, constant: 14), d.centerYAnchor.constraint(equalTo: pull.centerYAnchor)]
         trailing = d
       }
+      if notice.details?.decision != nil {
+        // A decision can be settled from the banner itself: one click, no terminal, no more reminders.
+        let done = NSButton(title: "Done", target: self, action: #selector(markDone(_:)))
+        done.isBordered = false; done.font = .systemFont(ofSize: 12, weight: .medium); done.contentTintColor = .controlAccentColor
+        done.setAccessibilityLabel("Mark this decision handled")
+        done.translatesAutoresizingMaskIntoConstraints = false
+        root.addSubview(done)
+        constraints += [done.leadingAnchor.constraint(equalTo: trailing.trailingAnchor, constant: 14), done.centerYAnchor.constraint(equalTo: pull.centerYAnchor)]
+        trailing = done
+      }
       let dis = NSButton(title: "Dismiss", target: self, action: #selector(dismiss(_:)))
       dis.isBordered = false; dis.font = .systemFont(ofSize: 12); dis.contentTintColor = .secondaryLabelColor
       dis.translatesAutoresizingMaskIntoConstraints = false

package/helper/macos/menubar.swift

@@ -10,12 +10,18 @@
  * truth and this file never grows business logic. No network of its own, no
  * state of its own, no credentials — it cannot leak what it never holds.
  *
+ * The menu is also the daily review surface: every open thing — decisions for
+ * this human, what their side owes teammates, what teammates owe them — is a
+ * row with a copy button, and opens a centred panel with the whole text and the
+ * actions that settle it. Before that it was a status light that said "no
+ * decisions need your input" and left nothing to look at.
+ *
  *   pantheon-tray <absolute-path-to-pantheon> [poll-seconds]
  */
 import AppKit
 
 let argv = CommandLine.arguments
-if argv.count == 2, argv[1] == "version" { print("1"); exit(0) }
+if argv.count == 2, argv[1] == "version" { print("2"); exit(0) }
 guard argv.count >= 2 else {
   fputs("usage: pantheon-tray <path-to-pantheon> [poll-seconds]\n", stderr)
   exit(64)
@@ -43,9 +49,49 @@ struct TrayState {
   var surfaceBundleID = ""
   var decisionsPrompt = ""
   var decisions: [(id: String, body: String, detail: String, prompt: String)] = []
+  var items: [Item] = []
   var version = ""
 }
 
+/// One open thing, as the menu shows it and the panel expands it.
+struct Item {
+  let id: String
+  let kind: String          // decision | owed | waiting
+  let title: String
+  let headline: String
+  let detail: String
+  let prompt: String
+  let who: String           // member id, or "you"
+  let when: Double          // ms since epoch
+  let goal: String
+  let ref: String
+  let space: String
+
+  var isDecision: Bool { kind == "decision" }
+  var heading: String {
+    switch kind {
+    case "decision": return "Needs your decision"
+    case "owed": return "Your side owes this"
+    default: return "Waiting on \(who)"
+    }
+  }
+  /// "praneet · 2d ago · pantheon"
+  var subtitle: String {
+    var parts: [String] = []
+    if kind == "owed" { parts.append("you owe") } else if kind == "waiting" { parts.append(who) }
+    if when > 0 { parts.append(Item.age(when)) }
+    if !space.isEmpty { parts.append(space) }
+    return parts.joined(separator: " · ")
+  }
+  static func age(_ ms: Double) -> String {
+    let secs = max(0, Date().timeIntervalSince1970 - ms / 1000)
+    if secs < 90 { return "just now" }
+    if secs < 5400 { return "\(Int(secs / 60))m ago" }
+    if secs < 172_800 { return "\(Int(secs / 3600))h ago" }
+    return "\(Int(secs / 86_400))d ago"
+  }
+}
+
 /// Run a command with a hard timeout. The menu bar must never beachball
 /// because a laptop's relay is asleep — tray-status has its own network
 /// timeouts, this bounds the whole process as the backstop.
@@ -88,6 +134,21 @@ func fetchState() -> TrayState {
   s.surfaceName = j["surface_name"] as? String ?? "agent"
   s.surfaceBundleID = j["surface_bundle_id"] as? String ?? ""
   s.decisionsPrompt = j["decisions_prompt"] as? String ?? ""
+  for i in (j["items"] as? [[String: Any]] ?? []) {
+    s.items.append(Item(
+      id: i["id"] as? String ?? "",
+      kind: i["kind"] as? String ?? "decision",
+      title: i["title"] as? String ?? "",
+      headline: i["headline"] as? String ?? i["title"] as? String ?? "",
+      detail: i["detail"] as? String ?? i["title"] as? String ?? "",
+      prompt: i["prompt"] as? String ?? "",
+      who: i["who"] as? String ?? "",
+      when: (i["when"] as? Double) ?? Double(i["when"] as? Int ?? 0),
+      goal: i["goal"] as? String ?? "",
+      ref: i["ref"] as? String ?? "",
+      space: i["space"] as? String ?? ""
+    ))
+  }
   for d in (j["decisions"] as? [[String: Any]] ?? []) {
     s.decisions.append((
       id: d["id"] as? String ?? "",
@@ -99,6 +160,111 @@ func fetchState() -> TrayState {
   return s
 }
 
+
+/**
+ * One open thing, as a menu row: title, a dim second line, and a copy control on
+ * the right. Clicking the row opens the detail panel; clicking the copy glyph
+ * puts the agent prompt on the clipboard and LEAVES THE MENU OPEN, so a person
+ * reviewing four things can take all four without reopening the menu each time.
+ *
+ * Drawn by hand rather than assembled from controls: a menu runs its own event
+ * loop, and hit-testing two zones in one view is far more predictable there than
+ * nesting buttons inside an NSMenuItem.
+ */
+final class RowView: NSView {
+  private let item: Item
+  private let onOpen: (Item) -> Void
+  private let onCopy: (Item) -> Void
+  private var hovering = false
+  private var overCopy = false
+  private var copied = false
+
+  init(item: Item, width: CGFloat, onOpen: @escaping (Item) -> Void, onCopy: @escaping (Item) -> Void) {
+    self.item = item
+    self.onOpen = onOpen
+    self.onCopy = onCopy
+    super.init(frame: NSRect(x: 0, y: 0, width: width, height: item.subtitle.isEmpty ? 30 : 42))
+    setAccessibilityRole(.button)
+    setAccessibilityLabel("\(item.title). \(item.subtitle). Return opens it; the button on the right copies the question.")
+  }
+  required init?(coder: NSCoder) { return nil }
+
+  private var copyRect: NSRect { NSRect(x: bounds.maxX - 42, y: bounds.midY - 12, width: 28, height: 24) }
+
+  override func updateTrackingAreas() {
+    super.updateTrackingAreas()
+    for a in trackingAreas { removeTrackingArea(a) }
+    addTrackingArea(NSTrackingArea(rect: bounds, options: [.mouseEnteredAndExited, .activeAlways], owner: self, userInfo: ["zone": "row"]))
+    addTrackingArea(NSTrackingArea(rect: copyRect, options: [.mouseEnteredAndExited, .activeAlways], owner: self, userInfo: ["zone": "copy"]))
+  }
+  private func zone(_ e: NSEvent) -> String { (e.trackingArea?.userInfo?["zone"] as? String) ?? "row" }
+  override func mouseEntered(with e: NSEvent) {
+    if zone(e) == "copy" { overCopy = true } else { hovering = true }
+    needsDisplay = true
+  }
+  override func mouseExited(with e: NSEvent) {
+    if zone(e) == "copy" { overCopy = false } else { hovering = false; overCopy = false }
+    needsDisplay = true
+  }
+  override func mouseUp(with e: NSEvent) {
+    if copyRect.contains(convert(e.locationInWindow, from: nil)) {
+      onCopy(item)
+      copied = true
+      needsDisplay = true
+      DispatchQueue.main.asyncAfter(deadline: .now() + 1.4) { [weak self] in self?.copied = false; self?.needsDisplay = true }
+      return
+    }
+    enclosingMenuItem?.menu?.cancelTracking()
+    onOpen(item)
+  }
+
+  override func draw(_ dirtyRect: NSRect) {
+    let selected = hovering
+    if selected {
+      NSColor.selectedContentBackgroundColor.setFill()
+      NSBezierPath(roundedRect: bounds.insetBy(dx: 5, dy: 1), xRadius: 5, yRadius: 5).fill()
+    }
+    let fg: NSColor = selected ? .selectedMenuItemTextColor : .labelColor
+    let dim: NSColor = selected ? NSColor.selectedMenuItemTextColor.withAlphaComponent(0.7) : .secondaryLabelColor
+    let para = NSMutableParagraphStyle()
+    para.lineBreakMode = .byTruncatingTail
+    let textWidth = bounds.width - 14 - 48
+    let hasSub = !item.subtitle.isEmpty
+    let titleY = hasSub ? bounds.midY - 1 : bounds.midY - 8
+    NSAttributedString(string: item.title, attributes: [
+      .font: NSFont.systemFont(ofSize: 13, weight: .medium), .foregroundColor: fg, .paragraphStyle: para,
+    ]).draw(in: NSRect(x: 14, y: titleY, width: textWidth, height: 18))
+    if hasSub {
+      NSAttributedString(string: item.subtitle, attributes: [
+        .font: NSFont.systemFont(ofSize: 11), .foregroundColor: dim, .paragraphStyle: para,
+      ]).draw(in: NSRect(x: 14, y: bounds.midY - 17, width: textWidth, height: 15))
+    }
+
+    // the copy control
+    if overCopy || copied {
+      (selected ? NSColor.white.withAlphaComponent(0.22) : NSColor.labelColor.withAlphaComponent(0.10)).setFill()
+      NSBezierPath(roundedRect: copyRect, xRadius: 5, yRadius: 5).fill()
+    }
+    let glyphName = copied ? "checkmark" : "doc.on.doc"
+    let tint: NSColor = copied ? (selected ? .selectedMenuItemTextColor : .systemGreen) : (selected ? .selectedMenuItemTextColor : .secondaryLabelColor)
+    if let sym = NSImage(systemSymbolName: glyphName, accessibilityDescription: copied ? "Copied" : "Copy the question") {
+      let cfg = NSImage.SymbolConfiguration(pointSize: 12, weight: .medium)
+      let img = sym.withSymbolConfiguration(cfg) ?? sym
+      let size = img.size
+      let box = NSRect(x: copyRect.midX - size.width / 2, y: copyRect.midY - size.height / 2, width: size.width, height: size.height)
+      tint.set()
+      img.isTemplate = true
+      img.draw(in: box, from: .zero, operation: .sourceOver, fraction: 1.0)
+      NSColor.clear.set()
+    } else {
+      let p2 = NSMutableParagraphStyle(); p2.alignment = .center
+      NSAttributedString(string: copied ? "ok" : "copy", attributes: [
+        .font: NSFont.systemFont(ofSize: 10, weight: .medium), .foregroundColor: tint, .paragraphStyle: p2,
+      ]).draw(in: NSRect(x: copyRect.minX - 6, y: copyRect.midY - 6, width: copyRect.width + 12, height: 13))
+    }
+  }
+}
+
 final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   private var item: NSStatusItem!
   private var state = TrayState()
@@ -222,21 +388,26 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
         : "Connection unavailable · \(state.unavailableSpaces.joined(separator: ", "))")
       menu.addItem(.separator())
       if !state.decisionsOk {
-        info("Some decisions could not be checked")
-        info("Refresh to try again. The count may be incomplete.")
+        info("Some of this could not be checked")
+        info("Refresh to try again — the list may be incomplete")
       }
-      if state.decisions.isEmpty {
-        if state.decisionsOk { info("No decisions need your input") }
+      let decisions = state.items.filter { $0.kind == "decision" }
+      let owed = state.items.filter { $0.kind == "owed" }
+      let waiting = state.items.filter { $0.kind == "waiting" }
+      if state.items.isEmpty {
+        if state.decisionsOk { info("Nothing open — nothing needs you, nothing owed either way") }
       } else {
-        let noun = state.decisions.count == 1 ? "decision needs" : "decisions need"
-        info("\(state.decisions.count) \(noun) your input")
-        for d in state.decisions.prefix(5) {
-          let decision = makeItem(d.body.count > 72 ? String(d.body.prefix(71)) + "…" : d.body, #selector(openDecision(_:)))
-          decision.toolTip = d.detail
-          decision.representedObject = [d.id, d.prompt]
-          menu.addItem(decision)
+        addRows(menu, decisions.count == 1 ? "1 decision needs you" : "\(decisions.count) decisions need you", decisions)
+        addRows(menu, owed.count == 1 ? "You owe 1 thing" : "You owe \(owed.count) things", owed)
+        // Grouped by person, because "waiting on praneet" is what someone
+        // actually wants to know before they chase it.
+        for who in orderedPeers(waiting) {
+          let theirs = waiting.filter { $0.who == who }
+          addRows(menu, theirs.count == 1 ? "Waiting on \(who)" : "Waiting on \(who) · \(theirs.count)", theirs)
+        }
+        if !decisions.isEmpty {
+          menu.addItem(makeItem("\(decisions.count > 1 ? "Review all \(decisions.count) decisions" : "Review the decision") in \(state.surfaceName)", #selector(openAllDecisions)))
         }
-        menu.addItem(makeItem("\(state.decisions.count > 5 ? "Review all \(state.decisions.count) decisions" : "Review decisions") in \(state.surfaceName)", #selector(openAllDecisions)))
       }
       menu.addItem(.separator())
       info(state.workerRunning ? "Unattended work is on" : state.workerInstalled ? "Unattended work is paused" : "Unattended work is not set up")
@@ -274,6 +445,399 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     menu.addItem(makeItem("Quit pantheon menu bar", #selector(quit)))
   }
 
+
+  // MARK: the detail panel — the centred window a row opens
+
+  private var detailPanel: NSPanel?
+  private var panelItem: Item?
+  private var panelStatus: NSTextField?
+  private var panelText: NSTextView?
+  private var panelBodyHeight: NSLayoutConstraint?
+  private var panelHeadline: NSTextField?
+  private var panelRendered: NSAttributedString?     // the act laid out for a person
+  private var panelRaw: String = ""                  // the act exactly as it was sent
+  private var panelShowingRaw = false
+  private var panelRawToggle: NSButton?
+
+  private func label(_ text: String, size: CGFloat, weight: NSFont.Weight, color: NSColor, width: CGFloat) -> NSTextField {
+    let l = NSTextField(labelWithString: text)
+    l.font = .systemFont(ofSize: size, weight: weight)
+    l.textColor = color
+    l.lineBreakMode = .byWordWrapping
+    l.maximumNumberOfLines = 0
+    l.preferredMaxLayoutWidth = width
+    l.translatesAutoresizingMaskIntoConstraints = false
+    return l
+  }
+
+  /// How tall the body should be for this much text, between a compact minimum
+  /// and a cap that keeps the panel on screen.
+  private func bodyHeight(_ text: NSAttributedString, width: CGFloat) -> CGFloat {
+    let measured = text.boundingRect(with: NSSize(width: width - 4, height: .greatestFiniteMagnitude),
+                                     options: [.usesLineFragmentOrigin, .usesFontLeading]).height
+    return min(max(ceil(measured) + 22, 96), 400)
+  }
+
+  private func plain(_ text: String) -> NSAttributedString {
+    let para = NSMutableParagraphStyle()
+    para.paragraphSpacing = 10
+    para.lineSpacing = 1.5
+    return NSAttributedString(string: text, attributes: [
+      .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: para,
+    ])
+  }
+
+  /**
+   * The act as blocks: paragraphs, the options as bullets, shell commands in a
+   * monospace run. The parsing is the CLI's (`pantheon tray-detail`), because it
+   * is testable there and this file stays a renderer.
+   */
+  private func render(_ blocks: [[String: Any]]) -> NSAttributedString {
+    let out = NSMutableAttributedString()
+    let body = NSMutableParagraphStyle()
+    body.paragraphSpacing = 12
+    body.lineSpacing = 1.5
+    let bullet = NSMutableParagraphStyle()
+    bullet.paragraphSpacing = 5
+    bullet.lineSpacing = 1.5
+    bullet.headIndent = 20
+    bullet.firstLineHeadIndent = 6
+    let code = NSMutableParagraphStyle()
+    code.paragraphSpacing = 2
+    code.headIndent = 20
+    code.firstLineHeadIndent = 12
+
+    for block in blocks {
+      let kind = block["kind"] as? String ?? "para"
+      if kind == "para", let text = block["text"] as? String {
+        out.append(NSAttributedString(string: text + "\n", attributes: [
+          .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: body,
+        ]))
+      } else if kind == "bullets", let items = block["items"] as? [String] {
+        for item in items {
+          out.append(NSAttributedString(string: "•  " + item + "\n", attributes: [
+            .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: bullet,
+          ]))
+        }
+        out.append(NSAttributedString(string: "\n", attributes: [.font: NSFont.systemFont(ofSize: 5)]))
+      } else if kind == "code", let lines = block["lines"] as? [String] {
+        for line in lines {
+          out.append(NSAttributedString(string: line + "\n", attributes: [
+            .font: NSFont.monospacedSystemFont(ofSize: 12, weight: .regular),
+            .foregroundColor: NSColor.labelColor,
+            .backgroundColor: NSColor.labelColor.withAlphaComponent(0.06),
+            .paragraphStyle: code,
+          ]))
+        }
+        out.append(NSAttributedString(string: "\n", attributes: [.font: NSFont.systemFont(ofSize: 5)]))
+      }
+    }
+    return out
+  }
+
+  private func showBody(_ text: NSAttributedString, width: CGFloat) {
+    guard let tv = panelText else { return }
+    tv.textStorage?.setAttributedString(text)
+    panelBodyHeight?.constant = bodyHeight(text, width: width)
+    if let p = detailPanel {
+      p.contentView?.layoutSubtreeIfNeeded()
+      let h = min(max((p.contentView?.fittingSize.height ?? 420) + 30, 300), 680)
+      let f = p.frame
+      p.setFrame(NSRect(x: f.minX, y: f.maxY - h, width: f.width, height: h), display: true, animate: false)
+    }
+  }
+
+  /**
+   * The relay's obligation body is ONE clipped line — enough for a menu row, not
+   * for a panel that says "here is the whole thing". So fetch the act behind it
+   * and lay it out. On demand, only while a panel is open.
+   */
+  private func loadDetail(_ item: Item, width: CGFloat) {
+    guard !item.ref.isEmpty else { return }
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["tray-detail", item.ref], timeout: 20)
+      guard let out = r?.out, r?.code == 0,
+            let data = out.data(using: .utf8),
+            let j = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            j["ok"] as? Bool == true else { return }
+      let blocks = j["blocks"] as? [[String: Any]] ?? []
+      let rendered = self.render(blocks)
+      let raw = j["raw"] as? String ?? ""
+      let headline = j["headline"] as? String ?? ""
+      DispatchQueue.main.async {
+        guard self.panelItem?.id == item.id else { return }
+        self.panelRendered = rendered
+        self.panelRaw = raw
+        self.panelRawToggle?.isHidden = raw.isEmpty
+        if !headline.isEmpty { self.panelHeadline?.stringValue = headline }
+        if !self.panelShowingRaw && rendered.length > 0 { self.showBody(rendered, width: width) }
+      }
+    }
+  }
+
+  /// Reformatting someone else's words is only honest if the original is one click away.
+  @objc private func panelToggleRaw() {
+    guard let item = panelItem else { return }
+    panelShowingRaw.toggle()
+    panelRawToggle?.title = panelShowingRaw ? "Show it laid out" : "Show it as sent"
+    let width: CGFloat = 620 - 52
+    if panelShowingRaw { showBody(plain(panelRaw.isEmpty ? item.detail : panelRaw), width: width) }
+    else if let r = panelRendered { showBody(r, width: width) }
+  }
+
+  /**
+   * Everything about one open thing, in the middle of the screen: who it is
+   * from, the whole text (a menu row can only ever show a clipped line), and the
+   * actions that settle it. The menu answers "is anything waiting"; this answers
+   * "what is it, and what do I do about it" without a terminal.
+   */
+  func showDetail(_ item: Item) {
+    detailPanel?.close()
+    panelItem = item
+    let width: CGFloat = 620
+    let inner = width - 52
+    let panel = NSPanel(contentRect: NSRect(x: 0, y: 0, width: width, height: 470),
+                        styleMask: [.titled, .closable, .fullSizeContentView], backing: .buffered, defer: false)
+    panel.title = "Pantheon"
+    panel.titlebarAppearsTransparent = true
+    panel.isMovableByWindowBackground = true
+    panel.level = .floating
+    panel.isReleasedWhenClosed = false
+    panel.hidesOnDeactivate = false
+
+    let effect = NSVisualEffectView(frame: NSRect(x: 0, y: 0, width: width, height: 470))
+    effect.material = .popover
+    effect.blendingMode = .behindWindow
+    effect.state = .active
+    effect.autoresizingMask = [.width, .height]
+
+    let stack = NSStackView()
+    stack.orientation = .vertical
+    stack.alignment = .leading
+    stack.spacing = 9
+    stack.translatesAutoresizingMaskIntoConstraints = false
+    effect.addSubview(stack)
+
+    var eyebrow = item.heading.uppercased()
+    if item.when > 0 { eyebrow += "  ·  " + Item.age(item.when) }
+    if !item.space.isEmpty { eyebrow += "  ·  " + item.space }
+    let eye = label(eyebrow, size: 11, weight: .semibold, color: .secondaryLabelColor, width: inner)
+    stack.addArrangedSubview(eye)
+    let headline = label(item.headline, size: 17, weight: .semibold, color: .labelColor, width: inner)
+    panelHeadline = headline
+    stack.addArrangedSubview(headline)
+
+    // the whole text, selectable and scrollable — a decision is often several paragraphs
+    let scroll = NSScrollView()
+    scroll.hasVerticalScroller = true
+    scroll.drawsBackground = false
+    scroll.borderType = .noBorder
+    scroll.translatesAutoresizingMaskIntoConstraints = false
+    let tv = NSTextView()
+    tv.isEditable = false
+    tv.isSelectable = true
+    tv.drawsBackground = false
+    tv.font = .systemFont(ofSize: 13)
+    tv.textColor = .labelColor
+    tv.textStorage?.setAttributedString(plain(item.detail))
+    tv.textContainerInset = NSSize(width: 0, height: 6)
+    tv.isVerticallyResizable = true
+    tv.isHorizontallyResizable = false
+    tv.autoresizingMask = [.width]
+    tv.textContainer?.widthTracksTextView = true
+    scroll.documentView = tv
+    panelText = tv
+    stack.addArrangedSubview(scroll)
+    stack.setCustomSpacing(14, after: stack.arrangedSubviews[1])
+
+    var meta = item.isDecision ? "decision \(item.id)" : "obligation \(item.id)"
+    if !item.goal.isEmpty { meta += "  ·  goal \(item.goal)" }
+    stack.addArrangedSubview(label(meta, size: 11, weight: .regular, color: .tertiaryLabelColor, width: inner))
+
+    let status = label("", size: 11, weight: .medium, color: .secondaryLabelColor, width: inner)
+    status.isHidden = true
+    panelStatus = status
+    stack.addArrangedSubview(status)
+
+    let row = NSStackView()
+    row.orientation = .horizontal
+    row.spacing = 10
+    row.translatesAutoresizingMaskIntoConstraints = false
+    let open = NSButton(title: "Open in \(state.surfaceName)", target: self, action: #selector(panelOpen))
+    open.bezelStyle = .rounded
+    open.keyEquivalent = "\r"
+    row.addArrangedSubview(open)
+    let copy = NSButton(title: "Copy the question", target: self, action: #selector(panelCopy))
+    copy.bezelStyle = .rounded
+    row.addArrangedSubview(copy)
+    if item.isDecision {
+      let done = NSButton(title: "Mark done", target: self, action: #selector(panelDone))
+      done.bezelStyle = .rounded
+      done.toolTip = "Answer it as handled, so it stops asking"
+      row.addArrangedSubview(done)
+    }
+    let thread = NSButton(title: "Show the thread", target: self, action: #selector(panelThread))
+    thread.bezelStyle = .rounded
+    row.addArrangedSubview(thread)
+    let rawToggle = NSButton(title: "Show it as sent", target: self, action: #selector(panelToggleRaw))
+    rawToggle.bezelStyle = .rounded
+    rawToggle.toolTip = "The act exactly as your teammate's agent wrote it"
+    rawToggle.isHidden = true
+    panelRawToggle = rawToggle
+    row.addArrangedSubview(rawToggle)
+    let close = NSButton(title: "Close", target: self, action: #selector(panelClose))
+    close.bezelStyle = .rounded
+    close.keyEquivalent = "\u{1b}"
+    row.addArrangedSubview(close)
+    stack.addArrangedSubview(row)
+
+    NSLayoutConstraint.activate([
+      stack.leadingAnchor.constraint(equalTo: effect.leadingAnchor, constant: 26),
+      stack.trailingAnchor.constraint(equalTo: effect.trailingAnchor, constant: -26),
+      stack.topAnchor.constraint(equalTo: effect.topAnchor, constant: 36),
+      stack.bottomAnchor.constraint(equalTo: effect.bottomAnchor, constant: -22),
+      scroll.widthAnchor.constraint(equalTo: stack.widthAnchor),
+      row.widthAnchor.constraint(lessThanOrEqualTo: stack.widthAnchor),
+    ])
+    let bh = scroll.heightAnchor.constraint(equalToConstant: bodyHeight(plain(item.detail), width: inner))
+    bh.isActive = true
+    panelBodyHeight = bh
+
+    panel.contentView = effect
+    // Sized to what it holds: a one-line question should not open a half-empty window.
+    effect.layoutSubtreeIfNeeded()
+    let height = min(max(effect.fittingSize.height + 30, 300), 660)
+    panel.setContentSize(NSSize(width: width, height: height))
+    panel.center()
+    detailPanel = panel
+    NSApp.activate(ignoringOtherApps: true)
+    panel.makeKeyAndOrderFront(nil)
+    panelRendered = nil
+    panelRaw = ""
+    panelShowingRaw = false
+    loadDetail(item, width: inner)
+  }
+
+  private func setStatus(_ text: String) {
+    panelStatus?.stringValue = text
+    panelStatus?.isHidden = text.isEmpty
+  }
+
+  @objc private func panelClose() {
+    detailPanel?.close()
+    detailPanel = nil
+    panelText = nil
+    panelBodyHeight = nil
+    panelItem = nil
+    panelHeadline = nil
+    panelRendered = nil
+    panelRawToggle = nil
+    panelRaw = ""
+    panelShowingRaw = false
+  }
+  @objc private func panelCopy() {
+    guard let item = panelItem else { return }
+    copyPrompt(item)
+    setStatus("Copied. Paste it into your agent.")
+  }
+  @objc private func panelOpen() {
+    guard let item = panelItem else { return }
+    panelClose()
+    openItem(item)
+  }
+  @objc private func panelThread() {
+    guard let item = panelItem else { return }
+    panelClose()
+    showThread(item)
+  }
+  /// Answer the decision as handled, with no terminal — the same action the alert's Done takes.
+  @objc private func panelDone() {
+    guard let item = panelItem, item.isDecision else { return }
+    setStatus("Marking it done…")
+    var payload: [String: Any] = ["action": "done", "decision": item.id]
+    if !item.ref.isEmpty { payload["act"] = item.ref }
+    guard writeAction(payload) else {
+      setStatus("Could not write the action. Use Show the thread instead.")
+      return
+    }
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["explain", "--queued"], timeout: 25)
+      DispatchQueue.main.async {
+        self.setStatus(r?.code == 0
+          ? "Done — it is no longer waiting on you."
+          : "Could not mark it done. Use Show the thread instead.")
+        self.refresh()
+      }
+    }
+  }
+
+  // MARK: item actions, shared by the menu rows and the panel
+
+  private func binDir() -> String {
+    (Bundle.main.executablePath as NSString?)?.deletingLastPathComponent
+      ?? URL(fileURLWithPath: CommandLine.arguments[0]).deletingLastPathComponent().path
+  }
+  /// What `pantheon explain --queued` reads. Same file the desktop alert writes.
+  private func writeAction(_ payload: [String: Any]) -> Bool {
+    guard let data = try? JSONSerialization.data(withJSONObject: payload) else { return false }
+    return (try? data.write(to: URL(fileURLWithPath: binDir() + "/.hud-action.json"), options: .atomic)) != nil
+  }
+  func copyPrompt(_ item: Item) {
+    let pb = NSPasteboard.general
+    pb.clearContents()
+    pb.setString(item.prompt, forType: .string)
+  }
+  /// Open the agent with this item's question already written out.
+  func openItem(_ item: Item) {
+    copyPrompt(item)
+    if writeAction(["action": "open", "prompt": item.prompt]) {
+      openCommand("pantheon-explain.command")
+    } else {
+      reportFailure("Could not open your agent. The question is copied; paste it into your agent.")
+    }
+  }
+  /// The act behind it, in Terminal, with the reply menu.
+  func showThread(_ item: Item) {
+    var payload: [String: Any] = ["action": "details"]
+    if !item.ref.isEmpty { payload["act"] = item.ref }
+    if item.isDecision { payload["decision"] = item.id }
+    if writeAction(payload) { openCommand("pantheon-details.command") }
+    else { reportFailure("Could not open Terminal. Run pantheon doctor to check your setup.") }
+  }
+
+  /// Peers in the order their oldest unanswered thing arrived — longest wait first.
+  private func orderedPeers(_ items: [Item]) -> [String] {
+    var seen: [String] = []
+    for i in items.sorted(by: { $0.when < $1.when }) where !seen.contains(i.who) { seen.append(i.who) }
+    return seen
+  }
+
+  /// A titled group of rows. Six at most: a menu is for triage, and anything
+  /// deeper belongs in `pantheon brief`, which the last row opens.
+  private func addRows(_ menu: NSMenu, _ title: String, _ items: [Item]) {
+    guard !items.isEmpty else { return }
+    let header = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+    header.isEnabled = false
+    header.attributedTitle = NSAttributedString(string: title, attributes: [
+      .font: NSFont.systemFont(ofSize: 11, weight: .semibold),
+      .foregroundColor: NSColor.secondaryLabelColor,
+    ])
+    menu.addItem(header)
+    for item in items.prefix(6) {
+      let mi = NSMenuItem(title: item.title, action: nil, keyEquivalent: "")
+      mi.toolTip = item.detail
+      mi.view = RowView(item: item, width: 360,
+                        onOpen: { [weak self] it in self?.showDetail(it) },
+                        onCopy: { [weak self] it in self?.copyPrompt(it) })
+      menu.addItem(mi)
+    }
+    if items.count > 6 {
+      let more = NSMenuItem(title: "…and \(items.count - 6) more", action: nil, keyEquivalent: "")
+      more.isEnabled = false
+      menu.addItem(more)
+    }
+  }
+
   private func makeItem(_ title: String, _ sel: Selector) -> NSMenuItem {
     let mi = NSMenuItem(title: title, action: sel, keyEquivalent: "")
     mi.target = self
@@ -307,10 +871,6 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   @objc private func openStatus() { openCommand("pantheon-status.command") }
   @objc private func openDoctor() { openCommand("pantheon-doctor.command") }
   @objc private func openApprovals() { openCommand("pantheon-approvals.command") }
-  @objc private func openDecision(_ sender: NSMenuItem) {
-    let pair = sender.representedObject as? [String] ?? []
-    openAgent(id: pair.first ?? "all", prompt: pair.count > 1 ? pair[1] : "")
-  }
   @objc private func openAllDecisions() { openAgent(id: "all", prompt: state.decisionsPrompt) }
   /**
    * The handoff: queue the chosen decision id for `pantheon explain --queued`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.24.1",
+  "version": "0.24.4",
   "description": "Let your coding agent collaborate directly with your teammates' agents — ask, agree an interface, and deliver, without a human relaying messages.",
   "type": "module",
   "bin": {