@join-pantheon/cli 0.26.3 → 0.26.5

package/README.md

@@ -499,7 +499,7 @@ All enforced in the relay, not in a prompt — a prompt can be argued out of its
 
 | Guard | Default | Why |
 |---|---|---|
-| Loop guard | 6 acts in a row | one delegate cannot monologue; only a peer act resets the run |
+| Loop guard | 6 acts in a row | one delegate cannot monologue; only a peer act resets the run. Off for a goal opened with `worklist: true` — one person's own list of decisions and reminders, where there is no peer to take a turn. The act budget still applies there. |
 | Goal budget | 80 acts | a runaway goal stalls and raises a human obligation instead of burning tokens |
 | Rate limit | 40 acts / 10s | per member |
 | Body cap | 32000 chars | over 2000 needs a one-line summary — a peer reading six thousand words misses paragraph nine |

package/dist/cli.js

@@ -326,6 +326,20 @@ async function guidedSetup(cfg, project, opts = {}) {
         rl?.close();
     }
 }
+async function workdirFor(cfg, hud) {
+    const { loadAll, findMembership } = await import("./config.js");
+    const { pickWorkdir } = await import("./workdir.js");
+    const all = loadAll();
+    const m = all ? findMembership(all, hud.space || cfg.space) : undefined;
+    const team = m?.name ?? cfg.space;
+    const bindings = all && m ? Object.values(all.bindings ?? {}).filter((b) => b.space === m.id) : [];
+    let hints = [];
+    if (bindings.length > 1 && hud.goal) {
+        const acts = await fetchHistory(cfg).catch(() => []);
+        hints = acts.filter((x) => x.goal === hud.goal).flatMap((x) => [x.body, JSON.stringify(x.meta ?? {})]);
+    }
+    return pickWorkdir(bindings, hints, team);
+}
 async function fetchHistory(cfg, since = 0) {
     const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
     const res = await fetch(`${base}/history?space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}&since=${since}`, { signal: AbortSignal.timeout(8000) });
@@ -963,7 +977,7 @@ async function main() {
                 if (!goals.length)
                     console.log(`  ${D("(none)")}`);
                 for (const g of goals) {
-                    console.log(`  ${g.state.padEnd(8)} ${String(g.acts).padStart(3)}/${g.budget}  ${g.title}  ${D(g.id)}`);
+                    console.log(`  ${g.state.padEnd(8)} ${String(g.acts).padStart(3)}/${g.budget}  ${g.title}${g.kind === "worklist" ? D("  [worklist]") : ""}  ${D(g.id)}`);
                 }
                 const owed = client.obligations;
                 const ageOf = (t) => {
@@ -2262,6 +2276,46 @@ async function main() {
                 }
                 return;
             }
+            if (hud?.action === "reply") {
+                const notSent = (why) => { console.log(`not sent: ${why.split("\n")[0]}`); process.exit(1); };
+                const kind = hud.kind ?? "NOTE";
+                const body = (hud.body ?? "").trim();
+                if (!body)
+                    notSent("nothing to send");
+                const c2 = new PantheonClient(cfg, undefined, { role: "cli" });
+                await c2.connect().catch((e) => notSent(e.message));
+                const o = hud.decision ? c2.obligations.find((x) => x.id === hud.decision) : undefined;
+                const acts = await fetchHistory(cfg).catch(() => []);
+                const target = acts.find((x) => x.id === (o?.ref ?? hud.act));
+                const goal = o?.goal ?? target?.goal ?? hud.goal ?? null;
+                if (kind === "ANSWER" && !o && !target) {
+                    c2.close();
+                    notSent("that decision is no longer waiting — nothing to answer");
+                }
+                const ref = kind === "ANSWER" ? (o?.ref ?? target?.id ?? null) : kind === "ASK" ? (target?.id ?? null) : null;
+                const to = kind === "ASK" ? (target && target.from !== cfg.member ? [target.from] : null) : null;
+                if (kind === "ASK" && !to) {
+                    c2.close();
+                    notSent("cannot tell who raised this — use Show the thread and reply from there");
+                }
+                const sent = await c2.send({ act: kind, body, goal, ref, to, after_seq: c2.readSeq, meta: { surface: "menubar" } })
+                    .catch((e) => notSent(e.message));
+                c2.close();
+                console.log(`sent ${kind} id=${sent.id} seq=${sent.seq}`);
+                return;
+            }
+            if (hud?.action === "retract") {
+                const notSent = (why) => { console.log(`not sent: ${why.split("\n")[0]}`); process.exit(1); };
+                if (!hud.act)
+                    notSent("nothing to retract");
+                const c2 = new PantheonClient(cfg, undefined, { role: "cli" });
+                await c2.connect().catch((e) => notSent(e.message));
+                const sent = await c2.send({ act: "RETRACT", body: "Retracted from the menu bar.", goal: null, ref: hud.act, to: null, meta: { surface: "menubar" } })
+                    .catch((e) => notSent(e.message));
+                c2.close();
+                console.log(`sent RETRACT id=${sent.id} seq=${sent.seq}`);
+                return;
+            }
             if (hud?.action === "done") {
                 const c2 = new PantheonClient(cfg, undefined, { role: "cli" });
                 await c2.connect().catch((e) => die(e.message));
@@ -2278,6 +2332,15 @@ async function main() {
                 return;
             }
             if (hud?.action === "details") {
+                const wd = await workdirFor(cfg, hud).catch(() => null);
+                if (wd?.path) {
+                    try {
+                        process.chdir(wd.path);
+                    }
+                    catch { }
+                }
+                if (wd)
+                    console.error(D(`  ${wd.note}`));
                 const acts = await fetchHistory(cfg).catch(() => []);
                 const a = hud.act ? acts.find((x) => x.id === hud.act) : undefined;
                 let o;
@@ -2377,6 +2440,10 @@ async function main() {
             }
             if (hud?.action === "open") {
                 const p = loadProfile(cfg);
+                const wd = await workdirFor(cfg, hud).catch(() => null);
+                const cwd = wd?.path ?? undefined;
+                if (wd)
+                    console.error(D(`  ${wd.note}`));
                 if (hud.tool && isAgentSurface(hud.tool) && p.agent.primary_surface !== hud.tool) {
                     saveProfile({ ...p, agent: { ...p.agent, primary_surface: hud.tool }, updated_at: Date.now() });
                     console.error(D(`${hud.tool} is now where your decisions open`));
@@ -2388,7 +2455,7 @@ async function main() {
                     const { spawnSync } = await import("node:child_process");
                     {
                         const sp = agentSpawn(bin, [hud.prompt]);
-                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...(cwd ? { cwd } : {}), ...sp.options });
                     }
                     return;
                 }
@@ -2400,12 +2467,18 @@ async function main() {
                     const { spawnSync } = await import("node:child_process");
                     {
                         const sp = agentSpawn(agent.binary, launchArgs(agent.id, hud.prompt, sessionName(hud.prompt)));
-                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...(cwd ? { cwd } : {}), ...sp.options });
                     }
                     return;
                 }
                 if (hud.decision)
                     id = hud.decision;
+                if (cwd) {
+                    try {
+                        process.chdir(cwd);
+                    }
+                    catch { }
+                }
             }
             const client = new PantheonClient(cfg, undefined, { role: "cli" });
             await client.connect().catch((e) => die(e.message));

package/dist/history-view.js

@@ -8,7 +8,8 @@ export function selectActs(acts, opts = {}) {
 }
 const when = (ts) => new Date(ts).toISOString().slice(0, 19).replace("T", " ") + "Z";
 export function formatAct(a, opts = {}) {
-    const who = `${a.from}${a.role && a.role !== "interactive" ? ` (${a.role})` : ""}`;
+    const surface = a.meta?.surface;
+    const who = `${a.from}${surface === "menubar" ? " (from the menu bar)" : a.role && a.role !== "interactive" ? ` (${a.role})` : ""}`;
     const head = `[${a.seq}] ${a.act} from ${who}${a.to?.length ? ` to ${a.to.join(",")}` : ""}  ${when(a.ts)}  id=${a.id}${a.ref ? `  ref=${a.ref}` : ""}${a.goal ? `  goal=${a.goal}${opts.goalTitle ? ` "${opts.goalTitle}"` : ""}` : ""}`;
     if (opts.short)
         return `${head}\n    ${(a.summary ?? a.body).split("\n")[0].slice(0, 160)}`;

package/dist/ledger.js

@@ -35,6 +35,9 @@ export class Ledger {
     since(seq, limit = 500) {
         return this.records.filter((r) => r.seq > seq).slice(0, limit);
     }
+    latest(limit = 500) {
+        return this.records.slice(Math.max(0, this.records.length - limit));
+    }
     byGoal(goal, limit = 200) {
         const hits = this.records.filter((r) => r.goal === goal);
         return hits.slice(Math.max(0, hits.length - limit));

package/dist/mcp-instructions.js

@@ -8,7 +8,8 @@ export function protocol() {
   4. back to 1
 
 Keep looping while any goal you are in is OPEN. Stop only when every goal you are in is
-CLOSED, or when you have ESCALATED and are genuinely waiting on your human.
+CLOSED, or when you have ESCALATED and are genuinely waiting on your human. A goal marked
+[worklist] is one person's own list: it does not keep you in the loop.
 
 RULES
 - Talk to peers, not to your human. If a peer could answer it, ASK the peer instead of asking your human.
@@ -33,6 +34,7 @@ RULES
 - Verdict first, evidence after, and short: a peer reads your act in one screen. Say when you edited
   your own human's working tree as a side effect, and leave those edits uncommitted for them.
 - If pantheon_send returns PEER_TURN you have been talking to yourself — go back to pantheon_wait.
+  Filing reminders and decisions for your OWN human is not that: open the goal with worklist: true.
 
 The relay only moves messages. It has no access to your files, your shell, or your credentials.
 

package/dist/mcp.js

@@ -5,6 +5,7 @@ import { PantheonClient } from "./client.js";
 import { fenceBlock, fenceRubric, assess, fenceReminder } from "./untrusted.js";
 import { resolveFor } from "./config.js";
 import { LIMITS, SENDABLE } from "./protocol.js";
+import { goalKindLabel, openedText } from "./worklist.js";
 import { VERSION } from "./version.js";
 import { installedVersion } from "./mcp-supervisor.js";
 import { backendFromLabel } from "./agents.js";
@@ -246,7 +247,7 @@ export async function runMcp() {
                 ? `peers: ${peers.map((p) => `${p.id} [${p.online ? "online" : "offline"}, ${p.agent}${reach(p)}]`).join("  ")}`
                 : `peers: none yet — you are the only delegate here. Your human's colleague needs to run 'pantheon join'.`,
             open.length
-                ? `open goals:\n${open.map((g) => `  ${g.id}  ${g.state}  ${g.acts}/${g.budget} acts  "${g.title}"  members: ${g.members.join(",")}${deadlineLabel(g.deadline)}`).join("\n")}`
+                ? `open goals:\n${open.map((g) => `  ${g.id}  ${g.state}  ${g.acts}/${g.budget} acts  "${g.title}"  members: ${g.members.join(",")}${deadlineLabel(g.deadline)}${goalKindLabel(g)}`).join("\n")}`
                 : `open goals: none`,
             mine.length
                 ? `YOURS TO HANDLE (claim before working):\n${mine.map((o) => `  ${o.id}  ${o.kind}${o.claimed_by ? " [yours]" : ""} (ref ${o.ref}) — ${o.body}`).join("\n")}`
@@ -415,8 +416,11 @@ export async function runMcp() {
             deadline: z.string().optional().describe("when this goal should be closed by, ISO 8601 with timezone (e.g. 2026-08-28T22:00:00+04:00). " +
                 "Shown on every status line, and shown OVERDUE when passed — a deadline that lives only in prose is not tracked by anything."),
             distinct_from_open_goals: z.boolean().optional().describe("confirm this goal is NOT the same work as any currently open goal. Required when an open goal already involves the same members."),
+            worklist: z.boolean().optional().describe("this goal is your human's OWN list — decisions with deadlines and reminders you file for them, which peers may read but " +
+                "nobody owes anything in. Turns off the six-acts-in-a-row guard for this goal (the act budget still applies) and it does not " +
+                "keep you in the loop. Use it when your human asks you to set up reminders or a pipeline for themselves; never for shared work."),
         },
-    }, async ({ title, acceptance, invite, deadline, distinct_from_open_goals }) => guard(async () => {
+    }, async ({ title, acceptance, invite, deadline, distinct_from_open_goals, worklist }) => guard(async () => {
         let deadlineMs;
         if (deadline !== undefined) {
             deadlineMs = Date.parse(deadline);
@@ -427,7 +431,7 @@ export async function runMcp() {
                 return fail(`deadline ${new Date(deadlineMs).toISOString()} is already in the past — check the timezone.`);
             }
         }
-        if (!distinct_from_open_goals) {
+        if (!distinct_from_open_goals && !worklist) {
             const overlapping = overlappingOpenGoals(client.goals.values(), cfg.member, invite, client.roster.map((m) => m.id));
             if (overlapping.length) {
                 return fail(`not opened — ${overlapping.length} open goal(s) already involve the same members:\n` +
@@ -436,9 +440,13 @@ export async function runMcp() {
                     `If yours is genuinely distinct work, call pantheon_open_goal again with distinct_from_open_goals: true.`);
             }
         }
-        const r = await client.openGoal({ title, acceptance, ...(invite ? { invite } : {}), ...(deadlineMs !== undefined ? { deadline: deadlineMs } : {}) });
-        return text(`goal ${r.id} opened: "${title}"${deadlineMs !== undefined ? `\n${deadlineLabel(deadlineMs).trim()}` : ""}` +
-            `\n\nNext: PROPOSE how to split it, then wait for peers to ACCEPT or OBJECT.`);
+        const r = await client.openGoal({
+            title, acceptance,
+            ...(invite ? { invite } : {}),
+            ...(deadlineMs !== undefined ? { deadline: deadlineMs } : {}),
+            ...(worklist ? { kind: "worklist" } : {}),
+        });
+        return text(openedText(r.id, title, !!worklist, client.goals.get(r.id), deadlineMs !== undefined ? `\n${deadlineLabel(deadlineMs).trim()}` : ""));
     }));
     server.registerTool("pantheon_claim", {
         title: "Claim a piece of work",
@@ -465,6 +473,7 @@ export async function runMcp() {
         url.pathname = "/history";
         url.searchParams.set("space", cfg.space);
         url.searchParams.set("token", cfg.token);
+        url.searchParams.set("goal", goal);
         return fetch(url).then(async (res) => {
             const { acts } = (await res.json());
             const hits = acts.filter((a) => a.goal === goal).slice(-(limit ?? 60));

package/dist/protocol.js

@@ -179,6 +179,7 @@ export const OpenGoal = z.object({
     invite: z.array(z.string().min(1).max(48)).max(16).optional(),
     budget: z.number().int().min(4).max(1000).optional(),
     deadline: z.number().int().positive().optional(),
+    kind: z.enum(["worklist"]).optional(),
 });
 export const Ping = z.object({ t: z.literal("ping") });
 export const DeleteSpace = z.object({

package/dist/relay.js

@@ -288,7 +288,10 @@ export class Relay {
             const token = url.searchParams.get("token") ?? "";
             if (!space || space.token !== token)
                 return this.json(res, 404, { error: "no such space" });
-            return this.json(res, 200, { acts: space.ledger.since(Number(url.searchParams.get("since") ?? 0)) });
+            const goal = url.searchParams.get("goal");
+            const since = Number(url.searchParams.get("since") ?? 0);
+            const acts = goal ? space.ledger.byGoal(goal) : since > 0 ? space.ledger.since(since) : space.ledger.latest();
+            return this.json(res, 200, { acts, head: space.ledger.head });
         }
         if (url.pathname === "/obligations") {
             const space = this.spaces.get(url.searchParams.get("space") ?? "");
@@ -1964,6 +1967,7 @@ pantheon signup --email you@work.com --username you</code></pre>
                     opened_by: me.id,
                     opened_at: Date.now(),
                     ...(m.deadline !== undefined ? { deadline: m.deadline } : {}),
+                    ...(m.kind !== undefined ? { kind: m.kind } : {}),
                 };
                 space.goals.set(goal.id, goal);
                 space.store.save(space.goals, space.obligations, space.profiles);
@@ -1971,7 +1975,8 @@ pantheon signup --email you@work.com --username you</code></pre>
                 const rec = this.commit(space, {
                     from: me.id, act: "NOTE", to: null, goal: goal.id, ref: null,
                     body: `goal opened: ${goal.title}\nacceptance: ${goal.acceptance || "(none stated)"}` +
-                        (goal.deadline ? `\ndeadline: ${new Date(goal.deadline).toISOString()}` : ""),
+                        (goal.deadline ? `\ndeadline: ${new Date(goal.deadline).toISOString()}` : "") +
+                        (goal.kind === "worklist" ? `\nkind: worklist — ${me.id}'s own list; peers may read it, nobody owes anything in it` : ""),
                 });
                 this.send(ws, { t: "ack", ...(m.cid ? { cid: m.cid } : {}), id: goal.id, seq: rec.seq });
                 return;
@@ -2229,11 +2234,13 @@ pantheon signup --email you@work.com --username you</code></pre>
             return { code: "GOAL_CLOSED", message: `goal "${goal.title}" is closed` };
         if (!goal.members.includes(me.id))
             return { code: "NOT_IN_GOAL", message: `you are not a member of "${goal.title}"` };
-        if (goal.acts >= goal.budget) {
+        const settlesOwnHuman = act === "ANSWER" && !!ref
+            && [...sp.obligations.values()].some((o) => o.kind === "HUMAN" && o.ref === ref && o.owner === `human:${me.id}`);
+        if (goal.acts >= goal.budget && !settlesOwnHuman) {
             return { code: "BUDGET_SPENT", message: `goal "${goal.title}" spent its ${goal.budget}-act budget and needs a human` };
         }
         const run = sp.lastActor.get(goalId);
-        if (run && run.member === me.id && run.run >= LIMITS.consecutive && act !== "ESCALATE" && act !== "CLOSE") {
+        if (!settlesOwnHuman && goal.kind !== "worklist" && run && run.member === me.id && run.run >= LIMITS.consecutive && act !== "ESCALATE" && act !== "CLOSE") {
             return {
                 code: "PEER_TURN",
                 message: `you have sent ${run.run} acts in a row in "${goal.title}". Wait for a peer (pantheon_wait), or ESCALATE if nobody can move it.`,

package/dist/tray.js

@@ -131,14 +131,14 @@ async function trayStatusOne(cfg) {
     const items = [
         ...mineHuman.map((o) => {
             const from = senderOf(o);
-            return row(o, "decision", !from || from === cfg.member ? "your agent" : from, decisionPrompt(o.id, decisionTitle(o.body)));
+            return { ...row(o, "decision", !from || from === cfg.member ? "your agent" : from, decisionPrompt(o.id, decisionTitle(o.body))), decider: cfg.member };
         }),
         ...owed.map((o) => row(o, "owed", "you", owedPrompt(decisionTitle(o.body), o.goal))),
         ...waiting.map((o) => {
             const who = o.owner.replace(/^human:/, "");
             const r = row(o, "waiting", who, waitingPrompt(who, decisionTitle(o.body), o.goal));
             return o.owner.startsWith("human:")
-                ? { ...r, title: `${who} decides: ${r.title}`, headline: `${who} decides: ${r.headline}` }
+                ? { ...r, title: `${who} decides: ${r.title}`, headline: `${who} decides: ${r.headline}`, decider: who }
                 : r;
         }),
     ];

package/dist/workdir.js

@@ -0,0 +1,30 @@
+import { existsSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+export function gitActivity(path) {
+    for (const f of ["index", "FETCH_HEAD", "HEAD"]) {
+        try {
+            return statSync(join(path, ".git", f)).mtimeMs;
+        }
+        catch { }
+    }
+    return 0;
+}
+export function pickWorkdir(bindings, hints, team, activity = gitActivity, exists = existsSync) {
+    const live = bindings.filter((b) => exists(b.path));
+    if (!live.length) {
+        return {
+            path: null,
+            note: `no folder on this machine is bound to "${team}", so this opens in your home folder. To fix it, run  pantheon use ${team} --here  inside the repo.`,
+        };
+    }
+    const named = live.filter((b) => hints.some((h) => (b.origin ? h.includes(b.origin) : false) || h.includes(b.path)));
+    const pool = named.length ? named : live;
+    const chosen = [...pool].sort((x, y) => (activity(y.path) - activity(x.path)) || (y.bound_at - x.bound_at))[0];
+    const others = live.filter((b) => b.path !== chosen.path).map((b) => basename(b.path));
+    const why = named.length ? "named in this goal" : live.length > 1 ? "your most recent git activity" : "";
+    return {
+        path: chosen.path,
+        note: `in ${basename(chosen.path)}${why ? ` (${why})` : ""}${others.length ? ` — "${team}" is also bound to ${others.join(", ")}` : ""}`,
+    };
+}
+//# sourceMappingURL=workdir.js.map

package/dist/worklist.js

@@ -0,0 +1,17 @@
+export function goalKindLabel(g) {
+    return g.kind === "worklist" ? "  [worklist — one person's own list; nobody owes anything here, and it does not keep you in the loop]" : "";
+}
+export function openedText(id, title, askedWorklist, seen, deadlineLine = "") {
+    const head = `goal ${id} opened: "${title}"${deadlineLine}`;
+    if (!askedWorklist)
+        return `${head}\n\nNext: PROPOSE how to split it, then wait for peers to ACCEPT or OBJECT.`;
+    if (seen?.kind !== "worklist") {
+        return `${head}\n\nOpened as an ORDINARY goal: this relay is older than the worklist feature and ignored the flag. ` +
+            `The six-acts-in-a-row guard still applies here, so file items in batches of six and expect PEER_TURN between them ` +
+            `until the relay is upgraded.`;
+    }
+    return `${head}  [worklist]\n\nThis is your human's own list. File each item as one act: ESCALATE for a decision they must make ` +
+        `(with its deadline in the body), NOTE for a reminder. Nobody owes anything here, PEER_TURN never fires, ` +
+        `and this goal does not keep you in the loop — the act budget still applies.`;
+}
+//# sourceMappingURL=worklist.js.map

package/helper/macos/menubar.swift

@@ -68,6 +68,8 @@ struct Item {
   let goal: String
   let ref: String
   let space: String
+  /// whose human must decide this: this member for their own decision, the teammate for theirs, "" when it is not a decision
+  let decider: String
 
   var isDecision: Bool { kind == "decision" }
   var heading: String {
@@ -152,7 +154,8 @@ func fetchState() -> TrayState {
       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 ?? ""
+      space: i["space"] as? String ?? "",
+      decider: i["decider"] as? String ?? ""
     ))
   }
   for d in (j["decisions"] as? [[String: Any]] ?? []) {
@@ -840,7 +843,17 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   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 var panelRawButton: NSButton?              // "Original text" / "Laid out", shown only when the two differ
+  private var panelButtons: NSStackView?             // the action row; hidden while replying
+  private var panelReplyRow: NSStackView?            // the reply box; shown only in reply mode
+  private var panelCancel: NSButton?
+  private var panelReplyButton: NSButton?           // the primary action, hidden while replying
+  private var panelStatusRow: NSStackView?           // collapses when there is nothing to say
+  private var panelReply: NSTextView?                // the person's own words
+  private var panelReplyKind: NSPopUpButton?         // Answer / Note / Ask back
+  private var panelSendButton: NSButton?
+  private var panelRetract: NSButton?                // the undo, for a minute after a send
+  private var panelLastSent: String = ""             // act id of what was just sent
 
   private func label(_ text: String, size: CGFloat, weight: NSFont.Weight, color: NSColor, width: CGFloat) -> NSTextField {
     let l = NSTextField(labelWithString: text)
@@ -951,7 +964,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
         guard self.panelItem?.id == item.id else { return }
         self.panelRendered = rendered
         self.panelRaw = raw
-        self.panelRawToggle?.isHidden = raw.isEmpty
+        self.panelRawButton?.isHidden = raw.isEmpty
         if !headline.isEmpty { self.panelHeadline?.stringValue = headline }
         if !self.panelShowingRaw && rendered.length > 0 { self.showBody(rendered, width: width) }
       }
@@ -962,7 +975,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   @objc private func panelToggleRaw() {
     guard let item = panelItem else { return }
     panelShowingRaw.toggle()
-    panelRawToggle?.title = panelShowingRaw ? "Show it laid out" : "Show it as sent"
+    panelRawButton?.title = panelShowingRaw ? "Laid out" : "Original text"
     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) }
@@ -1037,42 +1050,161 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     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)
+    // Whose decision this is, said before the box that answers it. Your own
+    // answer to a teammate's decision lands as an act and settles nothing, so the
+    // panel offers Answer only to the person it is waiting on.
+    let owner: String = item.isDecision ? "Yours to decide."
+      : !item.decider.isEmpty ? "\(item.decider)'s to decide. You can add a note or ask back."
+      : item.kind == "owed" ? "Your agent owes this. You can add a note or ask back."
+      : "Waiting on \(item.who). You can add a note or ask back."
+    let ownerRow = NSStackView()
+    ownerRow.orientation = .horizontal
+    ownerRow.alignment = .centerY
+    ownerRow.spacing = 10
+    ownerRow.translatesAutoresizingMaskIntoConstraints = false
+    let ownerLabel = label(owner, size: 12, weight: .medium, color: .secondaryLabelColor, width: inner - 170)
+    ownerLabel.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    ownerRow.addArrangedSubview(ownerLabel)
+    let ownerSpacer = NSView()
+    ownerSpacer.translatesAutoresizingMaskIntoConstraints = false
+    ownerSpacer.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    ownerRow.addArrangedSubview(ownerSpacer)
+    // The one action that is the person's own voice, set apart from the rest and
+    // reachable with Return. Pressing it only opens the box; nothing is sent.
+    let replyBtn = NSButton(title: "Reply manually", target: self, action: #selector(panelReplyManually))
+    replyBtn.bezelStyle = .rounded
+    replyBtn.keyEquivalent = "\r"
+    replyBtn.setContentCompressionResistancePriority(.required, for: .horizontal)
+    replyBtn.toolTip = "Type your own answer, note or question. Nothing is drafted for you, and nothing is sent until you press Send."
+    panelReplyButton = replyBtn
+    ownerRow.addArrangedSubview(replyBtn)
+    ownerRow.widthAnchor.constraint(equalToConstant: inner).isActive = true
+    if let idLine = stack.arrangedSubviews.last { stack.setCustomSpacing(6, after: idLine) }
+    stack.addArrangedSubview(ownerRow)
+    // Clear air between the person's own action and the rest: a rule, with room
+    // on both sides, so the blue button is not read as part of the row below.
+    stack.setCustomSpacing(22, after: ownerRow)
+    let rule = NSBox()
+    rule.boxType = .separator
+    rule.translatesAutoresizingMaskIntoConstraints = false
+    rule.widthAnchor.constraint(equalToConstant: inner).isActive = true
+    stack.addArrangedSubview(rule)
+    stack.setCustomSpacing(22, after: rule)
+
+    // The reply, in the person's own words: one popup for what it is, the box,
+    // one Send. Return sends; Shift-Return makes a new line.
+    let replyRow = NSStackView()
+    replyRow.orientation = .horizontal
+    replyRow.alignment = .top
+    replyRow.spacing = 8
+    replyRow.translatesAutoresizingMaskIntoConstraints = false
+    let kinds = NSPopUpButton(frame: .zero, pullsDown: false)
+    for k in replyKinds(item) { kinds.addItem(withTitle: k) }
+    kinds.toolTip = "Answer settles it and the agent continues. Note goes on the record and settles nothing. Ask back puts a question to the agent that raised it."
+    kinds.setContentHuggingPriority(.defaultHigh, for: .horizontal)
+    panelReplyKind = kinds
+    replyRow.addArrangedSubview(kinds)
+    let replyScroll = NSScrollView()
+    replyScroll.hasVerticalScroller = false
+    replyScroll.borderType = .bezelBorder
+    replyScroll.translatesAutoresizingMaskIntoConstraints = false
+    let reply = NSTextView()
+    reply.isEditable = true
+    reply.isRichText = false
+    reply.font = .systemFont(ofSize: 13)
+    reply.textContainerInset = NSSize(width: 4, height: 6)
+    reply.isVerticallyResizable = true
+    reply.isHorizontallyResizable = false
+    reply.autoresizingMask = [.width]
+    reply.textContainer?.widthTracksTextView = true
+    reply.delegate = self
+    replyScroll.documentView = reply
+    replyScroll.heightAnchor.constraint(equalToConstant: 58).isActive = true
+    replyScroll.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    panelReply = reply
+    replyRow.addArrangedSubview(replyScroll)
+    let send = NSButton(title: "Send", target: self, action: #selector(panelSend(_:)))
+    send.bezelStyle = .rounded
+    send.setContentHuggingPriority(.defaultHigh, for: .horizontal)
+    panelSendButton = send
+    replyRow.addArrangedSubview(send)
+    let cancel = NSButton(title: "Cancel", target: self, action: #selector(panelCancelReply))
+    cancel.bezelStyle = .rounded
+    cancel.setContentHuggingPriority(.defaultHigh, for: .horizontal)
+    cancel.toolTip = "Back to the buttons. Your words stay in the box."
+    panelCancel = cancel
+    replyRow.addArrangedSubview(cancel)
+    replyRow.widthAnchor.constraint(equalToConstant: inner).isActive = true
+    panelReplyRow = replyRow
+    stack.addArrangedSubview(replyRow)
+    replyRow.isHidden = true
+
+    // What happened, and the undo for a slip: Retract shows for a minute after a send.
+    let statusRow = NSStackView()
+    statusRow.orientation = .horizontal
+    statusRow.spacing = 10
+    statusRow.translatesAutoresizingMaskIntoConstraints = false
+    let status = label("", size: 11, weight: .medium, color: .secondaryLabelColor, width: inner - 90)
     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)
+    statusRow.addArrangedSubview(status)
+    let retract = NSButton(title: "Retract", target: self, action: #selector(panelRetractAction))
+    retract.bezelStyle = .rounded
+    retract.controlSize = .small
+    retract.toolTip = "Withdraws what you just sent. Your words stay in the record as retracted."
+    retract.isHidden = true
+    panelRetract = retract
+    statusRow.addArrangedSubview(retract)
+    panelStatusRow = statusRow
+    stack.addArrangedSubview(statusRow)
+    statusRow.isHidden = true
+
+    // Two rows: what to do about it, then what to do with the text. Every
+    // button refuses to compress, so the labels are always whole.
+    func button(_ title: String, _ sel: Selector, _ tip: String) -> NSButton {
+      let b = NSButton(title: title, target: self, action: sel)
+      b.bezelStyle = .rounded
+      b.toolTip = tip
+      b.setContentCompressionResistancePriority(.required, for: .horizontal)
+      return b
+    }
+    let rows = NSStackView()
+    rows.orientation = .vertical
+    rows.alignment = .leading
+    rows.spacing = 8
+    rows.translatesAutoresizingMaskIntoConstraints = false
+
+    let row1 = NSStackView()
+    row1.orientation = .horizontal
+    row1.spacing = 10
+    row1.addArrangedSubview(button("Explain in \(state.surfaceName)", #selector(panelOpen),
+      "Opens \(state.surfaceName) in the team's folder and asks it to lay out your options. It will not decide or reply for you."))
     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)
+      row1.addArrangedSubview(button("Mark done", #selector(panelDone), "Tells the agent you settled this in person, so it stops asking."))
     }
-    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"
+    row1.addArrangedSubview(button("Show the thread", #selector(panelThread), "Every act in this goal, in Terminal, from the team's folder."))
+    rows.addArrangedSubview(row1)
+
+    let row2 = NSStackView()
+    row2.orientation = .horizontal
+    row2.spacing = 10
+    row2.addArrangedSubview(button("Copy the question", #selector(panelCopy), "Copies the question and its context as text, for an email or a message."))
+    let rawToggle = button("Original text", #selector(panelToggleRaw), "Exactly as the agent wrote it, before Pantheon laid it out.")
     rawToggle.isHidden = true
-    panelRawToggle = rawToggle
-    row.addArrangedSubview(rawToggle)
-    let close = NSButton(title: "Close", target: self, action: #selector(panelClose))
-    close.bezelStyle = .rounded
+    panelRawButton = rawToggle
+    row2.addArrangedSubview(rawToggle)
+    let spacer = NSView()
+    spacer.translatesAutoresizingMaskIntoConstraints = false
+    spacer.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    row2.addArrangedSubview(spacer)
+    let close = button("Close", #selector(panelClose), "Nothing changes.")
     close.keyEquivalent = "\u{1b}"
-    row.addArrangedSubview(close)
-    stack.addArrangedSubview(row)
+    row2.addArrangedSubview(close)
+    row2.widthAnchor.constraint(equalToConstant: inner).isActive = true
+    rows.addArrangedSubview(row2)
+
+    panelButtons = rows
+    stack.addArrangedSubview(rows)
 
     NSLayoutConstraint.activate([
       stack.leadingAnchor.constraint(equalTo: effect.leadingAnchor, constant: 26),
@@ -1080,7 +1212,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
       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),
+      rows.widthAnchor.constraint(lessThanOrEqualTo: stack.widthAnchor),
     ])
     let bh = scroll.heightAnchor.constraint(equalToConstant: bodyHeight(plain(item.detail), width: inner))
     bh.isActive = true
@@ -1104,6 +1236,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   private func setStatus(_ text: String) {
     panelStatus?.stringValue = text
     panelStatus?.isHidden = text.isEmpty
+    panelStatusRow?.isHidden = text.isEmpty && (panelRetract?.isHidden ?? true)
   }
 
   @objc private func panelClose() {
@@ -1114,14 +1247,120 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     panelItem = nil
     panelHeadline = nil
     panelRendered = nil
-    panelRawToggle = nil
+    panelRawButton = nil
+    panelButtons = nil
+    panelReplyRow = nil
+    panelCancel = nil
+    panelReplyButton = nil
+    panelStatusRow = nil
+    panelReply = nil
+    panelReplyKind = nil
+    panelSendButton = nil
+    panelRetract = nil
+    panelLastSent = ""
     panelRaw = ""
     panelShowingRaw = false
   }
+  /// The question as text — what a person pasting into an email or a message
+  /// wants. The agent prompt still rides with Explain, which copies it as a
+  /// fallback when the agent cannot be opened.
   @objc private func panelCopy() {
     guard let item = panelItem else { return }
-    copyPrompt(item)
-    setStatus("Copied. Paste it into your agent.")
+    let pb = NSPasteboard.general
+    pb.clearContents()
+    pb.setString(item.headline + "\n\n" + plain(panelRaw.isEmpty ? item.detail : panelRaw).string, forType: .string)
+    setStatus("Copied the question.")
+  }
+
+  /// Reply mode: the buttons step aside and only the box remains, with Cancel to
+  /// bring them back. The body gives up a little height so the panel stays put.
+  @objc private func panelReplyManually() {
+    panelButtons?.isHidden = true
+    panelReplyButton?.isHidden = true
+    panelReplyButton?.keyEquivalent = ""
+    panelSendButton?.keyEquivalent = "\r"
+    panelReplyRow?.isHidden = false
+    if let c = panelBodyHeight, c.constant > 140 { c.constant -= 20 }
+    panelRetract?.isHidden = true
+    setStatus("")
+    if let tv = panelReply { detailPanel?.makeFirstResponder(tv) }
+  }
+  @objc private func panelCancelReply() { exitReplyMode() }
+  private func exitReplyMode() {
+    panelReplyRow?.isHidden = true
+    panelSendButton?.keyEquivalent = ""
+    panelButtons?.isHidden = false
+    panelReplyButton?.isHidden = false
+    panelReplyButton?.keyEquivalent = "\r"
+    if let c = panelBodyHeight, c.constant > 0 { c.constant += 20 }
+  }
+
+  /// What a person may send on this item. Answer only on their own decision:
+  /// anyone else's answer would land as an act and settle nothing.
+  private func replyKinds(_ item: Item) -> [String] {
+    item.isDecision ? ["Answer", "Note", "Ask back"] : ["Note", "Ask back"]
+  }
+  private func kindCode(_ title: String?) -> String {
+    switch title { case "Answer": return "ANSWER"; case "Ask back": return "ASK"; default: return "NOTE" }
+  }
+
+  /// Send the words in the box as the chosen act. The CLI does the sending and
+  /// prints "sent KIND id=… seq=…" or "not sent: why" on stdout; both are shown.
+  @objc private func panelSend(_ sender: Any?) {
+    guard let item = panelItem, let tv = panelReply else { return }
+    let text = tv.string.trimmingCharacters(in: .whitespacesAndNewlines)
+    if text.isEmpty { setStatus("Type your reply first."); return }
+    let kind = kindCode(panelReplyKind?.titleOfSelectedItem)
+    var payload: [String: Any] = ["action": "reply", "kind": kind, "body": text, "goal": item.goal, "space": item.space]
+    if item.isDecision { payload["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 }
+    setStatus("Sending…")
+    panelSendButton?.isEnabled = false
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["explain", "--queued"], timeout: 25)
+      DispatchQueue.main.async {
+        self.panelSendButton?.isEnabled = true
+        let out = (r?.out ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+        if r?.code == 0, let idTok = out.split(separator: " ").first(where: { $0.hasPrefix("id=") }) {
+          self.panelLastSent = String(idTok.dropFirst(3))
+          tv.string = ""
+          let what = 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."
+          self.setStatus(what)
+          self.exitReplyMode()
+          self.panelRetract?.isHidden = false
+          DispatchQueue.main.asyncAfter(deadline: .now() + 60) { [weak self] in self?.panelRetract?.isHidden = true }
+          self.refresh()
+        } else {
+          let why = out.hasPrefix("not sent: ") ? String(out.dropFirst("not sent: ".count)) : "the relay could not be reached"
+          self.setStatus("Not sent — \(why) Your words are still in the box.")
+        }
+      }
+    }
+  }
+
+  /// The undo. RETRACT withdraws the act; the record keeps it as retracted.
+  @objc private func panelRetractAction() {
+    guard !panelLastSent.isEmpty else { return }
+    let id = panelLastSent
+    guard writeAction(["action": "retract", "act": id]) else { setStatus("Could not write the action."); return }
+    setStatus("Retracting…")
+    panelRetract?.isEnabled = false
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["explain", "--queued"], timeout: 25)
+      DispatchQueue.main.async {
+        self.panelRetract?.isEnabled = true
+        if r?.code == 0 {
+          self.panelLastSent = ""
+          self.panelRetract?.isHidden = true
+          self.setStatus("Retracted.")
+          self.refresh()
+        } else {
+          let out = (r?.out ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+          self.setStatus("Could not retract — \(out.hasPrefix("not sent: ") ? String(out.dropFirst("not sent: ".count)) : "the relay could not be reached")")
+        }
+      }
+    }
   }
   @objc private func panelOpen() {
     guard let item = panelItem else { return }
@@ -1328,3 +1567,12 @@ let app = NSApplication.shared
 let delegate = AppDelegate()
 app.delegate = delegate
 app.run()
+
+extension AppDelegate: NSTextViewDelegate {
+  func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
+    guard textView === panelReply, commandSelector == #selector(NSResponder.insertNewline(_:)) else { return false }
+    if NSApp.currentEvent?.modifierFlags.contains(.shift) == true { return false }
+    panelSend(nil)
+    return true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.26.3",
+  "version": "0.26.5",
   "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": {