@join-pantheon/cli 0.21.3 → 0.22.0

package/README.md

@@ -45,21 +45,27 @@ out with `pantheon sessions`; every identity and membership event is in `pantheo
 audit`. (Self-hosting or on a LAN/tailnet? Accounts are optional — skip straight
 to `pantheon start`.)
 
-**Then, from your project's repo:**
+**Then, from your project's repo — or anywhere, if there is no repo yet (see below):**
 
 ```bash
 pantheon start
 ```
 
-**Your teammate, from their clone of the project:**
+**Your teammate, from their clone of the project if they have one:**
 
 ```bash
 pantheon join pantheons://relay.joinpantheon.network/acme#C1qhJfdHBaPjuG3jF48vcqrP
 ```
 
 Signed in, `pantheon start` puts your space on the hosted relay, so that link works from any
-network — no tunnel, no VPN. The space is named after your repo; if another team already took
-that name, start picks `<repo>-<you>` and says so (or choose your own with `--space`).
+network — no tunnel, no VPN. The space is named after the folder you run it from (your repo,
+usually); if another team already took that name, start picks `<name>-<you>` and says so. Choose
+your own with `--space` — always do that when there is no repo to name it after.
+
+**You do not need a git repository.** Messages, questions, decisions and escalations work from any
+folder. A repo adds exactly two things: handing over code (a `DELIVERED` names a pushed branch and
+commit) and letting a teammate wake this machine while you are away; `pantheon repo add` binds one
+whenever you have it.
 
 That's it — one command each sets up the **whole machine**: a relay and space (you) or membership
 (them), pantheon wired into whichever agents each of you already has (**user scope** — every project,
@@ -67,13 +73,17 @@ every Conductor window, nothing to commit), the wake-up hook so an agent finishe
 waiting for, the **worker** so the machine answers the team even while its human is away (on by
 default when run inside a git repo; `--no-worker` opts out — and a peer still needs an explicit
 `--may-wake` grant before they can use it), native decision alerts, and the menu bar. Each command
-ends with a "You're set" summary, then a short guided setup on a terminal: whether teammates may wake
-your machine while you are away, what a woken run may execute, who you are and which decisions are
-yours alone (so agents stop and ask you), and which alerts you want. Plain questions, mostly options;
-`pantheon setup` re-runs it any time — and an agent setting you up can run `pantheon setup --questions`, ask you in chat, and pass your answers back as flags, so nobody has to open a terminal. Restart your agent once and ask it *"check pantheon_status"*.
+ends with a "You're set" summary, then a short guided setup on a terminal: three questions — your
+name, your role, and (inside a repo) whether a run a teammate wakes may execute commands — and one
+screen of defaults to keep or change: who may wake your machine while you are away, which alerts you
+want, which decisions are yours alone (so agents stop and ask you), the worker's playbook and its base
+branch. `pantheon setup` re-runs it any time. An agent setting you up runs `pantheon setup --questions`,
+asks you in chat, and passes your answers back as flags — to `pantheon setup --yes`, or straight to
+`pantheon start` / `pantheon join`, which apply them the moment the team exists — so nobody has to
+open a terminal. Restart your agent once and ask it *"check pantheon_status"*.
 
 Already a member — new laptop, or just pulled a newer build? The same full setup is one command:
-`pantheon install --user` (from your project's repo).
+`pantheon install --user` (from your project's repo if you have one).
 
 **Consent happens once, here.** Setup pre-approves exactly the six pantheon *message* tools in
 each agent's own permission system (Claude Code `permissions.allow`, Cursor `Mcp()` tokens,
@@ -451,6 +461,7 @@ pantheon doctor                    preflight: node, keys, MCP entry, relay, memb
 pantheon worker / service          stay answerable while you are away (install as a service)
 pantheon persona                   list / init / show — what a woken worker may do
 pantheon spaces / use / repo       several teams on one machine — what is bound where; bind this repo; a team's repos
+pantheon history / show            read the thread, or one act, in full with ids — from a terminal, no agent needed
 pantheon sessions · logout         your devices and sessions; sign this machine out
 pantheon account delete            remove your account and everything the relay holds on you
 pantheon upgrade                   pull the latest release and re-wire your agents

package/dist/cli.js

@@ -8,7 +8,7 @@ process.emitWarning = ((warning, ...rest) => {
 });
 import { randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
 import { fromInvite, load, save, toInvite, resolveFor, loadAll, repoInfo, bindRepo, findMembership, setDefaultSpace, removeMembership, configFor, CONFIG_DIR, CONFIG_PATH, DEFAULT_RELAY, resolveForHook } from "./config.js";
 import { fmtLimit } from "./plans.js";
@@ -20,6 +20,7 @@ import { Worker } from "./worker.js";
 import { DEFAULT_REMINDER_MS, ensureNativeNotifier, HumanNotifier, sendDesktopNotification } from "./notifier.js";
 import { AGENT_SURFACES, applyProfileInit, cleanList, isAgentSurface, loadProfile, organizationProfile, profileInitialized, saveProfile, wakeDefault } from "./profile.js";
 import { runGuide, terminalIO, parseSetupFlags, questionnaire } from "./setup-guide.js";
+import { selectActs, formatAct, resolveRef } from "./history-view.js";
 import { doctor, render } from "./doctor.js";
 import { menubarProc, notifierProc, relayProc, workerProc, wiring, logFileFor, dataSummary, stopProc, statFile } from "./machine.js";
 import { assess } from "./untrusted.js";
@@ -321,6 +322,13 @@ async function guidedSetup(cfg, project, opts = {}) {
         rl?.close();
     }
 }
+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) });
+    if (!res.ok)
+        throw new Error(`relay answered ${res.status} for the ledger`);
+    return (await res.json()).acts ?? [];
+}
 function workerMidRun() {
     try {
         const s = JSON.parse(readFileSync(join(CONFIG_DIR, "worker-state.json"), "utf8"));
@@ -365,11 +373,16 @@ ${B("first time — verify your email once")}
   pantheon login --email you@work.com                    a second machine, same account
   pantheon whoami · pantheon sessions                      who you are; your devices & sessions
 
-${B("getting going — then two commands, run from your project's repo")}
+${B("getting going — two commands, from your project's repo if you have one")}
   pantheon start              you: sets up this whole machine + one line to send your teammate
   pantheon join <line>        them: that one line sets up their whole machine
   pantheon invite             another single-use line, for a third person or a second machine
 
+  Both take the setup answers as flags (--name, --title, --wake, --commands, … — pantheon setup
+  --questions lists them), so an agent sets a person up in one command. No repo? Messages, questions
+  and decisions work anywhere; a repo only adds handing over code and being woken. Name the team
+  with --space when there is no repo to name it after.
+
   One command does everything: agents wired and pre-approved, wake-up hook (your
   agent finishes what a peer is waiting for), worker (this machine answers the
   team while you are away — on when run from a git repo; a peer still needs an
@@ -416,9 +429,11 @@ ${B("control")}
   pantheon leave              remove what pantheon put on this machine
   pantheon panic              cut off all unattended work on this machine, now
   pantheon doctor             check this machine end to end
-  pantheon setup              the guided choices: who may wake this machine, what a run may execute,
-                              what you personally decide, which alerts you want — re-run any time
-                              (--questions prints them for an agent to ask you; answers go back as flags)
+  pantheon setup              three questions — your name, your role, may a woken run execute commands —
+                              then one screen of defaults to keep or change: who may wake this machine,
+                              alerts, what you personally decide, playbook, base branch. Re-run any time.
+                              (--questions prints them for an agent to ask you; answers go back as flags,
+                              to setup --yes or straight to start / join)
   pantheon upgrade            pull the latest pantheon, rebuild, and re-wire your agents
 
 ${D("more: pantheon help --all")}
@@ -432,6 +447,9 @@ ${B("less common")}
   pantheon whoami             your name and fingerprint
   pantheon pending            what a live agent window has not yet seen
   pantheon say <ACT> <text>   send one act by hand   (NOTE, ASK, ANSWER, PROPOSE, ...)
+                              replies pick the act they answer; --ref <id | seq | last> to choose
+  pantheon history            the thread in full, with ids   (--goal <id>, --from <who>, --last N, --short)
+  pantheon show <id | seq>    one act in full, and what it replied to
   pantheon invite             mint another single-use invite link to send
   pantheon install            re-wire this machine's agents (after a Node/agent change)
   pantheon mcp                the server your agent runs; not for you
@@ -457,9 +475,14 @@ async function main() {
     switch (cmd) {
         case "start": {
             const port = Number(flag("port", "8787"));
+            const setupFlags = parseSetupFlags(argv);
+            if (setupFlags.errors.length)
+                die(setupFlags.errors.join("\n") + "\n  pantheon setup --questions  lists every answer");
             const wp = unattendedProject();
             requireSignInOnHostedRelay(flag("relay"));
             console.error(`${B("pantheon start")}\n`);
+            if (!flag("space") && !repoInfo(process.cwd()))
+                console.error(D(`  No git repo here, so the team will be named after this folder: "${basename(process.cwd()).toLowerCase().replace(/[^a-z0-9._-]/g, "-") || "team"}". Pass --space <name> to choose.\n`));
             const r = await qsStart({
                 port,
                 dataDir: resolveDataDir(flag("data")).dir,
@@ -489,7 +512,7 @@ async function main() {
             if (r.invite) {
                 console.error(`\n${B("Send your teammate this one line — it sets up their whole machine:")}\n`);
                 console.error(`  ${C(`pantheon join ${r.invite}`)}\n`);
-                console.error(D(`  Tell them to run it from their project's git repo. Single use, expires in ${Math.round(Number(flag("ttl", "1440")) / 60)}h.`));
+                console.error(D(`  From their project's repo if they have one — a repo is only needed to hand over code or to be woken. Single use, expires in ${Math.round(Number(flag("ttl", "1440")) / 60)}h.`));
                 console.error(D(`  Redeeming it admits them — no separate approval step. Need another? \`pantheon invite\``));
                 console.error(D(`\n  Not technical? Forward them this instead, and their agent does the rest:`));
                 console.error(`  ${D("Tell your agent: run")} ${C("curl -fsSL https://www.joinpantheon.network/skills/join.md")} ${D("and follow it. Invite:")} ${C(`pantheon join ${r.invite}`)}`);
@@ -500,7 +523,7 @@ async function main() {
             }
             printReady(r.tools);
             if (r.claimed)
-                await guidedSetup(load() ?? r.cfg, repoInfo(process.cwd())?.root ?? null);
+                await guidedSetup(load() ?? r.cfg, repoInfo(process.cwd())?.root ?? null, { preset: setupFlags.preset, force: Object.keys(setupFlags.preset).length > 0 || argv.includes("--yes") });
             if (r.relay) {
                 console.error(D(`\nKeeping the relay running here. Ctrl-C stops it (your teammate goes offline too).`));
                 await new Promise(() => { });
@@ -593,7 +616,10 @@ async function main() {
             return;
         }
         case "join": {
-            const invite = argv[1] ?? die("usage: pantheon join pantheon://host/space#token");
+            const invite = argv[1] ?? die("usage: pantheon join pantheon://host/space#token [setup answers as flags — pantheon setup --questions]");
+            const setupFlags = parseSetupFlags(argv);
+            if (setupFlags.errors.length)
+                die(setupFlags.errors.join("\n") + "\n  pantheon setup --questions  lists every answer");
             let parsed;
             try {
                 parsed = fromInvite(invite);
@@ -637,7 +663,7 @@ async function main() {
             {
                 const joined = load();
                 if (joined)
-                    await guidedSetup(joined, repoInfo(process.cwd())?.root ?? null);
+                    await guidedSetup(joined, repoInfo(process.cwd())?.root ?? null, { preset: setupFlags.preset, force: Object.keys(setupFlags.preset).length > 0 || argv.includes("--yes") });
             }
             console.error(`\n${D('Then ask your agent: "check pantheon_status and say hello to the team".')}`);
             return;
@@ -822,7 +848,7 @@ async function main() {
                 for (const o of human) {
                     const who = o.owner.replace(/^human:/, "");
                     const stale = Date.now() - o.created_at > 3_600_000;
-                    console.log(`  ${stale ? "\x1b[33m" : C("")}${who.padEnd(14)}${ageOf(o.created_at).padEnd(6)}\x1b[0m ${o.body}`);
+                    console.log(`  ${stale ? "\x1b[33m" : C("")}${who.padEnd(14)}${ageOf(o.created_at).padEnd(6)}\x1b[0m ${o.body.split("\n")[0].slice(0, 110)}  ${D(o.ref)}`);
                     if (who === cfg.member)
                         console.log(`         ${D("your peer was told this decision was coming — answer it or say it is dropped")}`);
                 }
@@ -830,7 +856,10 @@ async function main() {
                 if (!between.length)
                     console.log(`  ${D("(nothing owed)")}`);
                 for (const o of between) {
-                    console.log(`  ${o.kind.padEnd(7)} ${o.owner.padEnd(14)}${ageOf(o.created_at).padEnd(6)} ${o.body}`);
+                    console.log(`  ${o.kind.padEnd(7)} ${o.owner.padEnd(14)}${ageOf(o.created_at).padEnd(6)} ${o.body.split("\n")[0].slice(0, 110)}  ${D(o.ref)}`);
+                }
+                if (human.length || between.length || goals.some((g) => g.state !== "CLOSED")) {
+                    console.log(D(`\n  read in full: pantheon show <id>  ·  a thread: pantheon history --goal <goal>  ·  reply: pantheon say ANSWER "…" --ref <id>`));
                 }
                 client.close();
             };
@@ -931,13 +960,58 @@ async function main() {
             console.log(argv.includes("--json") ? JSON.stringify(report) : renderPending(report));
             return;
         }
+        case "history": {
+            const cfg = need();
+            const acts = await fetchHistory(cfg, numFlag("since", 0)).catch((e) => die(`cannot read the ledger — ${e.message}`));
+            const picked = selectActs(acts, {
+                ...(flag("goal") ? { goal: flag("goal") } : {}), ...(flag("from") ? { from: flag("from") } : {}),
+                last: numFlag("last", 20), presence: argv.includes("--presence"),
+            });
+            if (argv.includes("--json")) {
+                console.log(JSON.stringify(picked, null, 2));
+                return;
+            }
+            if (!picked.length) {
+                console.log(D("no acts match"));
+                return;
+            }
+            const client = new PantheonClient(cfg, undefined, { role: "cli" });
+            const titles = new Map();
+            try {
+                await client.connect();
+                for (const g of client.goals.values())
+                    titles.set(g.id, g.title);
+            }
+            catch { }
+            finally {
+                client.close();
+            }
+            for (const a of picked)
+                console.log(formatAct(a, { short: argv.includes("--short"), ...(a.goal && titles.get(a.goal) ? { goalTitle: titles.get(a.goal) } : {}) }) + "\n");
+            console.log(D(`${picked.length} of ${acts.filter((a) => a.act !== "JOIN" && a.act !== "LEAVE").length} acts · --last N · --goal <id> · --from <member> · --short · --json  ·  reply: pantheon say ANSWER "…" --ref <id or seq>`));
+            return;
+        }
+        case "show": {
+            const cfg = need();
+            const key = argv[1] ?? die("usage: pantheon show <act id | sequence number>");
+            const acts = await fetchHistory(cfg).catch((e) => die(`cannot read the ledger — ${e.message}`));
+            const a = acts.find((x) => x.id === key || String(x.seq) === key) ?? die(`no act ${key} in what the relay still holds (pantheon history lists them)`);
+            console.log(formatAct(a));
+            if (a.ref) {
+                const r = acts.find((x) => x.id === a.ref);
+                if (r)
+                    console.log(D(`\nin reply to:\n`) + formatAct(r, { short: true }));
+            }
+            return;
+        }
         case "say": {
             const cfg = need();
-            const act = argv[1]?.toUpperCase() ?? die("usage: pantheon say <ACT> <body> [--goal id] [--to a,b] [--domains technical,gtm]");
+            const act = argv[1]?.toUpperCase() ?? die("usage: pantheon say <ACT> <body> [--goal id] [--to a,b] [--ref <id | seq | last>] [--summary 'one line'] [--domains technical,gtm]");
             const stop = argv.findIndex((a, i) => i >= 2 && a.startsWith("--"));
             const body = argv.slice(2, stop === -1 ? undefined : stop).join(" ");
             if (!body)
                 die("nothing to say — pantheon say NOTE 'your message here'");
+            const summary = flag("summary");
             const client = new PantheonClient(cfg, undefined, { role: "cli" });
             await client.connect().catch((e) => die(`cannot reach relay — ${e.message}`));
             const to = flag("to");
@@ -950,13 +1024,28 @@ async function main() {
             const domains = flag("domains");
             if (domains)
                 meta.decision_domains = cleanList(domains.split(","));
+            let goalArg = flag("goal") ?? null;
+            let ref = flag("ref") ?? null;
+            if (ref !== null || ["ANSWER", "ACCEPT", "OBJECT"].includes(act)) {
+                const acts = await fetchHistory(cfg).catch(() => []);
+                const rr = resolveRef(acts, ref, act, goalArg, cfg.member);
+                if (rr.error) {
+                    client.close();
+                    die(rr.error);
+                }
+                if (rr.note)
+                    console.error(D(`  ${rr.note}`));
+                ref = rr.id;
+                goalArg = goalArg ?? rr.goal;
+            }
             const r = await client.send({
                 act: act, body,
-                goal: flag("goal") ?? null,
+                goal: goalArg,
                 to: to ? to.split(",").map((s) => s.trim()) : null,
-                ref: flag("ref") ?? null,
+                ref,
+                ...(summary ? { summary } : {}),
                 ...(Object.keys(meta).length ? { meta } : {}),
-            }).catch((e) => die(e.message));
+            }).catch((e) => die(/SUMMARY_REQUIRED/.test(e.message) ? `${e.message}\n  Add one: --summary 'the point they must not miss'` : e.message));
             console.log(`sent ${act} id=${r.id} seq=${r.seq}`);
             client.close();
             return;
@@ -2013,10 +2102,13 @@ async function main() {
             const find = (want) => all.find((x) => x.o.id === want);
             if (sub === "answer") {
                 if (!id)
-                    die("usage: pantheon approvals answer <obligation-id> <decision>");
+                    die("usage: pantheon approvals answer <obligation-id> <decision> [--summary 'one line']");
                 const hit = find(id) ?? die(`no decision ${id} is waiting on you${conns.length > 1 ? ` in any of your ${conns.length} teams` : ""}`);
-                const answer = argv.slice(3).join(" ").trim() || die("state the decision; it will be written to the audit ledger");
-                const sent = await hit.client.send({ act: "ANSWER", body: answer, goal: null, ref: hit.o.ref, after_seq: hit.client.readSeq });
+                const stopAt = argv.findIndex((a, i) => i >= 3 && a.startsWith("--"));
+                const answer = argv.slice(3, stopAt === -1 ? undefined : stopAt).join(" ").trim() || die("state the decision; it will be written to the audit ledger");
+                const summary = flag("summary");
+                const sent = await hit.client.send({ act: "ANSWER", body: answer, goal: null, ref: hit.o.ref, after_seq: hit.client.readSeq, ...(summary ? { summary } : {}) })
+                    .catch((e) => { closeAll(); return die(/SUMMARY_REQUIRED/.test(e.message) ? `${e.message}\n  Add one: --summary 'the point they must not miss'` : e.message); });
                 console.log(`${C("answered")} ${id}${conns.length > 1 ? ` in ${B(hit.cfg.space)}` : ""} — ledger act ${sent.id}`);
                 closeAll();
                 return;

package/dist/history-view.js

@@ -0,0 +1,51 @@
+export function selectActs(acts, opts = {}) {
+    const kept = acts.filter((a) => (opts.presence || (a.act !== "JOIN" && a.act !== "LEAVE"))
+        && (opts.goal === undefined || a.goal === opts.goal)
+        && (opts.from === undefined || a.from === opts.from)
+        && (opts.since === undefined || a.seq > opts.since));
+    const n = opts.last ?? 20;
+    return kept.slice(Math.max(0, kept.length - n));
+}
+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 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)}`;
+    const meta = a.meta && Object.keys(a.meta).length ? `\n    meta: ${JSON.stringify(a.meta)}` : "";
+    const summary = a.summary ? `\n    >> ${a.summary}` : "";
+    return `${head}${summary}\n${a.body.split("\n").map((l) => `    ${l}`).join("\n")}${meta}`;
+}
+const REPLIES_TO = {
+    ANSWER: ["ASK", "ESCALATE", "HUMAN_REQUIRED"],
+    ACCEPT: ["DELIVERED", "PROPOSE", "CONTRACT"],
+    OBJECT: ["DELIVERED", "PROPOSE", "CONTRACT"],
+};
+export function resolveRef(acts, ref, act, goal, me) {
+    const inGoal = (a) => goal === null || a.goal === goal;
+    if (ref && /^a_/.test(ref)) {
+        const hit = acts.find((a) => a.id === ref);
+        return { id: ref, goal: hit?.goal ?? goal };
+    }
+    if (ref && /^\d+$/.test(ref)) {
+        const hit = acts.find((a) => a.seq === Number(ref));
+        return hit ? { id: hit.id, goal: hit.goal ?? goal, note: `replying to [${hit.seq}] ${hit.act} from ${hit.from}` } : { id: null, goal, error: `no act with sequence ${ref} in what this relay still holds` };
+    }
+    const others = acts.filter((a) => a.from !== me && a.act !== "JOIN" && a.act !== "LEAVE" && inGoal(a));
+    if (ref === "last") {
+        const hit = others[others.length - 1];
+        return hit ? { id: hit.id, goal: hit.goal ?? goal, note: `replying to [${hit.seq}] ${hit.act} from ${hit.from}` } : { id: null, goal, error: "nothing from a peer to reply to" };
+    }
+    if (ref)
+        return { id: ref, goal };
+    const wants = REPLIES_TO[act];
+    if (!wants)
+        return { id: null, goal };
+    for (const kind of wants) {
+        const hit = [...others].reverse().find((a) => a.act === kind && (!a.to?.length || a.to.includes(me)));
+        if (hit)
+            return { id: hit.id, goal: hit.goal ?? goal, note: `replying to [${hit.seq}] ${hit.act} from ${hit.from} (pass --ref to pick another)` };
+    }
+    return { id: null, goal, error: `${act} must reference the act it answers — none from a peer found${goal ? ` in ${goal}` : ""}. See pantheon history, then --ref <id or sequence number>` };
+}
+//# sourceMappingURL=history-view.js.map

package/dist/mcp.js

@@ -9,7 +9,7 @@ import { VERSION } from "./version.js";
 import { backendFromLabel } from "./agents.js";
 import { agentHookStates } from "./notify.js";
 import { reportMcpBusy, reportMcpIdle } from "./mcp-activity.js";
-import { loadProfile, organizationProfile, profileInitialized, routeDecision } from "./profile.js";
+import { loadProfile, organizationProfile, profileInitialized, routeDecision, reservedDecisionsNote } from "./profile.js";
 import { identityLine, renderBrief } from "./brief.js";
 import { recentRuns } from "./spend.js";
 const ACT_HELP = {
@@ -60,6 +60,7 @@ YOU WERE WOKEN BY A PEER. No human is present in this session.
 `
         : "";
     const profile = loadProfile(cfg);
+    const reserved = reservedDecisionsNote(profile);
     const identity = profileInitialized(profile)
         ? ` You work as ${identityLine({
             member: cfg.member,
@@ -87,7 +88,8 @@ RULES
   The organization directory — not job-title guesswork — determines whose human or agent owns it.
   When a peer's human personally must decide and their agent may be offline, use HUMAN_REQUIRED and name that one peer in to.
   Do not use HUMAN_REQUIRED instead of ASK for something their delegate can answer. Their delegate settles it with ANSWER.
-  ESCALATE and HUMAN_REQUIRED outlive a goal close until the named human has actually answered.
+  ESCALATE and HUMAN_REQUIRED outlive a goal close until the named human has actually answered.${reserved ? `
+- ${reserved}` : ""}
 - Agree the interface BEFORE writing code that crosses it: PROPOSE, then CONTRACT once accepted.
 - Answer every ASK addressed to you. An unanswered ASK blocks a peer and eventually stalls the goal.
 - ACCEPT means you actually checked. If something is wrong, OBJECT with the reason.

package/dist/profile.js

@@ -33,6 +33,14 @@ export function defaultProfile(cfg) {
         updated_at: 0,
     };
 }
+export function reservedDecisionsNote(profile) {
+    const mine = Object.entries(profile.authority).filter(([, m]) => m === "human_required").map(([d]) => d);
+    if (!mine.length)
+        return "";
+    return `YOUR HUMAN DECIDES THESE PERSONALLY: ${mine.join(", ")}. If a peer asks you to settle one — approve a
+deploy, agree a price, sign off a release — do not answer it yourself, however well you have checked the
+work. Say the review result if you have one, then ESCALATE and stop; tell the peer it is with your human.`;
+}
 export function wakeDefault(profile) {
     return (profile.agent.wake_default ?? "anyone") === "anyone";
 }

package/dist/setup-guide.js

@@ -59,7 +59,13 @@ export function questionnaire() {
     const opt = (flag, id, label) => `     ${label}  → --${flag} ${id}`;
     return [
         "pantheon setup — the questions, and the flag for each answer.",
-        "Ask your human each one in plain words, then run:  pantheon setup --yes <flags>",
+        "Ask your human in plain words, then pass the answers as flags — to `pantheon setup --yes`, or straight to",
+        "`pantheon start` / `pantheon join`, which apply them the moment the team exists.",
+        "",
+        "Only 3 and 4 need the person every time. Ask 2 whenever there is a repo (it is the one default people are",
+        "surprised by). The rest have defaults you may take and say out loud:",
+        "  --wake anyone --decides none --alerts decisions --playbook yes --base <what origin calls its default>",
+        "Without a repo, --wake, --commands, --playbook and --base do nothing yet: skip them and say so.",
         "",
         "1. While they're away, may teammates hand work to this machine? (their agent runs here on its own,",
         "   in a separate copy of the repo, and delivers on a branch for review)",
@@ -146,34 +152,66 @@ export async function runGuide(io, ctx, deps = {}, preset = {}) {
     }
     const applied = [], warnings = [];
     if (io) {
-        io.say("A few choices only you can make. Pick a number; Enter keeps the suggested one.\n");
-        const wakeIdx = await io.choose("While you're away, may teammates hand work to this machine? Your agent would run here on its own, in a separate copy of the repo, and deliver on a branch for review.", WAKE_OPTIONS.map((o) => o.label), Math.max(0, WAKE_OPTIONS.findIndex((o) => o.id === d.wake)));
-        a.wake = WAKE_OPTIONS[wakeIdx].id;
-        if (a.wake !== "no" && ctx.project) {
-            const c = await io.choose("When a teammate's request wakes this machine, what may the run do?", ["Edit files only — it can answer questions and draft changes, but cannot run tests, commit, or push.",
-                "Run commands too — needed to run tests and to commit and push work for review. Only requests from people you granted wake permission start a run."], a.commands ? 1 : 0);
-            a.commands = c === 1;
-        }
-        else if (a.wake === "no") {
-            a.commands = false;
-        }
+        io.say("Three questions, then one screen of defaults. Enter keeps the suggested answer.\n");
         a.name = (await io.ask("Your name, as teammates will see it", d.name)).trim() || d.name;
         const known = TITLE_OPTIONS.findIndex((t) => t.toLowerCase() === d.title.toLowerCase());
         const t = await io.choose("Your role, in a word — it goes on the team directory", TITLE_OPTIONS, known >= 0 ? known : d.title ? TITLE_OPTIONS.length - 1 : 0);
         a.title = t === TITLE_OPTIONS.length - 1 ? (await io.ask("Your role", d.title)).trim() || d.title || "Member" : TITLE_OPTIONS[t];
-        const picks = await io.chooseMany("Which of these do you decide personally? Agents — yours and your teammates' — will stop and ask you before acting on them. Pick any number, or none.", DECISION_AREAS.map((x) => x.label), d.decides.map((id) => DECISION_AREAS.findIndex((x) => x.id === id)).filter((i) => i >= 0));
-        a.decides = [...new Set(picks.map((i) => DECISION_AREAS[i].id))];
-        const n = await io.choose("Which desktop alerts do you want?", ALERT_OPTIONS.map((o) => o.label), Math.max(0, ALERT_OPTIONS.findIndex((o) => o.id === d.notifications)));
-        a.notifications = ALERT_OPTIONS[n].id;
+        const askCommands = async () => {
+            const undecided = profile.agent.allow_bash === undefined && preset.commands === undefined;
+            const c = await io.choose("Teammates can hand work to this machine while you're away. It runs in a separate copy of the repo and delivers on a branch you review. May a run also execute commands?", ["Yes — run tests, commit, and push work for review (recommended)",
+                "No — edit files and answer only; it cannot run tests, commit, or push"], undecided || a.commands ? 0 : 1);
+            a.commands = c === 0;
+        };
+        let commandsAsked = false;
         if (a.wake !== "no" && ctx.project) {
-            const p = await io.choose("Should your worker follow a short written playbook for this repo? It says what a woken run may do here and what it must leave to you. You can edit it any time.", ["Yes — write a starter playbook now (recommended)", "Not now"], 0);
-            a.persona = p === 0;
+            await askCommands();
+            commandsAsked = true;
         }
         const detected = ctx.project && deps.setRepoBase ? detectBaseBranch(ctx.project) : null;
-        if (detected) {
-            const suggested = preset.base ?? detected;
-            const b = await io.choose("Which branch should your worker start from, and deliveries be checked against? Usually the branch this project deploys or releases from.", [`${suggested}${suggested === detected ? " (what origin calls its default)" : ""}`, "A different branch"], 0);
-            a.base = b === 0 ? suggested : ((await io.ask("Branch name", suggested)).trim() || suggested);
+        const suggestedBase = detected ? (preset.base ?? detected) : undefined;
+        if (a.wake !== "no" && ctx.project)
+            a.persona = preset.persona ?? true;
+        const shortAlert = (id) => ALERT_OPTIONS.find((o) => o.id === id).label.split(" — ")[0].replace(/ \(recommended\)/, "");
+        io.say("\nThe rest has defaults. Change them now, or any time with `pantheon setup`:");
+        io.say(`  • Wake: ${a.wake === "no" ? "off — this machine only works while you are at it"
+            : !ctx.project ? "on once this machine has a repo (run pantheon setup from your project's repo)"
+                : a.wake === "anyone" ? "teammates may hand work to this machine while you're away; invites you send grant it, and you can revoke anyone (pantheon admit <name> --revoke)"
+                    : "only people you approve by hand (pantheon admit <name> --may-wake)"}`);
+        io.say(`  • Alerts: ${shortAlert(a.notifications).toLowerCase()}`);
+        io.say(`  • Decisions: ${a.decides.length ? `you personally decide ${a.decides.join(", ")}` : "none reserved for you — your agent may decide; add an area when one comes up"}`);
+        if (a.wake !== "no" && ctx.project)
+            io.say(`  • Playbook: ${a.persona ? "a short starter playbook for your worker, in this repo" : "none"}`);
+        if (suggestedBase)
+            io.say(`  • Base branch: ${suggestedBase}${suggestedBase === detected ? " (what origin calls its default)" : ""}`);
+        const keep = await io.choose("Keep these?", ["Keep them (recommended)", "Change some"], 0);
+        if (keep === 0) {
+            if (suggestedBase)
+                a.base = suggestedBase;
+        }
+        else {
+            const wakeIdx = await io.choose("While you're away, may teammates hand work to this machine? Your agent would run here on its own, in a separate copy of the repo, and deliver on a branch for review.", WAKE_OPTIONS.map((o) => o.label), Math.max(0, WAKE_OPTIONS.findIndex((o) => o.id === a.wake)));
+            a.wake = WAKE_OPTIONS[wakeIdx].id;
+            if (a.wake === "no") {
+                a.commands = false;
+                a.persona = false;
+            }
+            else if (ctx.project && !commandsAsked) {
+                await askCommands();
+                a.persona = preset.persona ?? true;
+            }
+            const picks = await io.chooseMany("Which of these do you decide personally? Agents — yours and your teammates' — will stop and ask you before acting on them. Pick any number, or none.", DECISION_AREAS.map((x) => x.label), a.decides.map((id) => DECISION_AREAS.findIndex((x) => x.id === id)).filter((i) => i >= 0));
+            a.decides = [...new Set(picks.map((i) => DECISION_AREAS[i].id))];
+            const n = await io.choose("Which desktop alerts do you want?", ALERT_OPTIONS.map((o) => o.label), Math.max(0, ALERT_OPTIONS.findIndex((o) => o.id === a.notifications)));
+            a.notifications = ALERT_OPTIONS[n].id;
+            if (a.wake !== "no" && ctx.project) {
+                const p = await io.choose("Should your worker follow a short written playbook for this repo? It says what a woken run may do here and what it must leave to you. You can edit it any time.", ["Yes — write a starter playbook now (recommended)", "Not now"], a.persona ? 0 : 1);
+                a.persona = p === 0;
+            }
+            if (suggestedBase) {
+                const b = await io.choose("Which branch should your worker start from, and deliveries be checked against? Usually the branch this project deploys or releases from.", [`${suggestedBase}${suggestedBase === detected ? " (what origin calls its default)" : ""}`, "A different branch"], 0);
+                a.base = b === 0 ? suggestedBase : ((await io.ask("Branch name", suggestedBase)).trim() || suggestedBase);
+            }
         }
     }
     let next = a.title ? applyProfileInit(profile, { name: a.name, title: a.title }) : { ...profile, human: { ...profile.human, display_name: a.name } };

package/dist/worker.js

@@ -10,7 +10,7 @@ import { applyAnswer, loadPolicy, mayAsk, needsSelfUpgrade, recordAsk, savePolic
 import { agentHookStates, repairHook } from "./notify.js";
 import { fence, assess } from "./untrusted.js";
 import { allowed, recordRun } from "./spend.js";
-import { loadProfile } from "./profile.js";
+import { loadProfile, reservedDecisionsNote } from "./profile.js";
 import { clip, workerDoneNotice } from "./brief.js";
 import { loadPersonas, matchPersona, personaByName, personaMatches, effectivePolicy, personaBrief, describePersona, } from "./persona.js";
 import { isContinuationFor, LIMITS, shouldDeferToHuman } from "./protocol.js";
@@ -536,7 +536,8 @@ export class Worker {
             this.opts.log(`! ${detail}`);
             return { obligation: o, branch, worktree, ok: false, detail };
         }
-        const brief = makeBrief(branch) + baseNote(baseRef, baseSha);
+        const reserved = reservedDecisionsNote(loadProfile(this.cfg));
+        const brief = makeBrief(branch) + baseNote(baseRef, baseSha) + (reserved ? `\n\n${reserved}` : "");
         writeFileSync(join(worktree, ".pantheon-task.md"), brief);
         let command;
         let args;
@@ -692,6 +693,10 @@ export class Worker {
                 result = { ok: false, alreadyCurrent: false, from: VERSION, to: relayPkg ?? "?" };
                 this.opts.log(`! self-upgrade failed: ${e.message}`);
             }
+            if (result.ok && !result.alreadyCurrent && result.to === result.from) {
+                this.opts.log(`* self-upgrade: the registry does not serve ${relayPkg} yet (installed ${result.to}); will check again`);
+                return;
+            }
             if (result.ok && !result.alreadyCurrent) {
                 await client.send({
                     act: "NOTE", goal: null, after_seq: client.readSeq,

package/package.json

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