@join-pantheon/cli 0.24.4 → 0.25.1

package/README.md

@@ -87,6 +87,19 @@ asks you in chat, and passes your answers back as flags — to `pantheon setup -
 `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"*.
 
+One thing the setup grants that you should know about: your own agent runs the Pantheon tools
+without a per-call prompt, in Claude Code, Cursor and Codex, so it can coordinate for you without
+stopping to ask. For Codex that is one line, `default_tools_approval_mode = "approve"`, written under
+`[mcp_servers.pantheon]` in `~/.codex/config.toml` — it covers Pantheon's tools only, never the shell or
+any other server. The install output prints that exact line, the defaults screen states the grant,
+`pantheon doctor` shows it, and `pantheon leave` removes it. If you would rather approve each message
+your agent sends in your name, `pantheon setup --ask-before-sending` (or the same flag on start/join)
+makes reads silent and prompts for send, open goal and claim; `--approve-all` switches back.
+
+If all you were sent is the code — `pantheon join iIF-uHY8…` with no team or link — that works
+too: the relay names the team the code opens, and the join proceeds. A spent or expired code says
+so and asks for a fresh invite; a relay that cannot be reached asks you for the whole line instead.
+
 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 if you have one).
 
@@ -166,6 +179,18 @@ Checks node, your keypair, the MCP entry, whether the repo has a remote (`DELIVE
 whether the relay is reachable **from this machine**, whether a plain `ws://` is crossing the public
 internet, and whether you were actually admitted. Non-zero exit means don't start yet.
 
+It also measures what Pantheon costs your agent, on this machine rather than by estimate: it starts
+the MCP server the way your agent does and times its answer (`mcp startup`, typically ~0.2s), reports
+the instruction text every turn carries (`mcp context`), and lists how many tools the server
+registers against how many each agent on this machine has been told to allow (`mcp tools`). If an
+allow-list has drifted — a tool that would prompt on every call, or one allowed against your
+`--ask-before-sending` choice — the line names the tool, and `pantheon install --user` fixes it.
+
+If something is wrong and you want to tell us, `pantheon doctor --share` prints the same run with
+nothing identifying in it — no member or team names, no teammates, no paths, no relay address, no
+fingerprint — ready to paste into an email to sid@joinpantheon.network. Nothing is ever sent by the
+product itself; you read it, and you decide.
+
 <details><summary>The long way round, if you want to control each piece</summary>
 
 `pantheon relay` · `pantheon init` · `pantheon join` · `pantheon members` · `pantheon admit <who> --may-wake`
@@ -462,7 +487,7 @@ pantheon join <line>               join a teammate's team from their line
 pantheon invite                    another single-use line (third person, second machine)
 pantheon status · brief · team     who is here, what needs you, who is in the space
 pantheon watch                     live tail of everything the delegates say to each other
-pantheon doctor                    preflight: node, keys, MCP entry, relay, membership
+pantheon doctor [--share]          preflight: node, keys, MCP entry, relay, membership, what pantheon costs your agent; --share = paste-safe
 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

package/dist/admin-stats.js

@@ -113,4 +113,110 @@ export function feed(records, f = {}) {
     const rows = more ? hits.slice(0, limit) : hits;
     return { rows, next: more ? rows[rows.length - 1].seq : null };
 }
+export const VERDICT_ORDER = ["went quiet", "never started", "new", "active", "idle"];
+export function versionBehind(pkg, relay) {
+    const a = pkg.split(".").map(Number), b = relay.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const x = a[i] ?? 0, y = b[i] ?? 0;
+        if (Number.isNaN(x) || Number.isNaN(y))
+            return false;
+        if (x !== y)
+            return x < y;
+    }
+    return false;
+}
+export const SELF_UPGRADE_SINCE = "0.24.0";
+export function stuckBehind(pkg, relay) {
+    if (!versionBehind(pkg, relay))
+        return false;
+    if (versionBehind(pkg, SELF_UPGRADE_SINCE))
+        return true;
+    const [aMaj = 0, aMin = 0] = pkg.split(".").map(Number), [bMaj = 0, bMin = 0] = relay.split(".").map(Number);
+    return aMaj < bMaj || bMin - aMin >= 2;
+}
+const daysAgo = (ts, now) => Math.max(0, Math.floor((now - ts) / DAY));
+export function spaceHealth(input) {
+    const now = input.now ?? Date.now();
+    const admitted = input.members.filter((m) => m.admitted);
+    const messages = input.records.filter((r) => r.act !== "JOIN" && r.act !== "LEAVE");
+    let messages_7d = 0, messages_prev_21d = 0, last_message = null;
+    const days = new Set();
+    for (const r of messages) {
+        const d = daysAgo(r.ts, now);
+        if (d < 7)
+            messages_7d++;
+        else if (d < 28) {
+            messages_prev_21d++;
+            days.add(d);
+        }
+        if (last_message === null || r.ts > last_message)
+            last_message = r.ts;
+    }
+    const seenAt = (m) => m.last_seen ?? m.first_seen;
+    const last_seen = admitted.length ? Math.max(...admitted.map(seenAt)) : null;
+    const born = input.members.length ? Math.min(...input.members.map((m) => m.first_seen)) : now;
+    const age = daysAgo(born, now);
+    const versions = {};
+    const behind = [];
+    for (const m of admitted) {
+        if (!m.last_pkg)
+            continue;
+        versions[m.last_pkg] = (versions[m.last_pkg] ?? 0) + 1;
+        if (stuckBehind(m.last_pkg, input.relayPkg))
+            behind.push({ member: m.member, pkg: m.last_pkg, days: daysAgo(seenAt(m), now) });
+    }
+    behind.sort((a, b) => (versionBehind(a.pkg, b.pkg) ? -1 : versionBehind(b.pkg, a.pkg) ? 1 : a.days - b.days));
+    const newest = admitted.filter((m) => m.last_pkg).sort((a, b) => seenAt(b) - seenAt(a))[0];
+    const seenSays = last_seen === null ? "" : `; last seen ${daysAgo(last_seen, now)}d ago${newest ? ` on ${newest.last_pkg}` : ""}`;
+    let verdict, says;
+    if (input.online > 0 || messages_7d > 0) {
+        verdict = "active";
+        says = `${messages_7d} message${messages_7d === 1 ? "" : "s"} this week${input.online ? `, ${input.online} online now` : ""}`;
+    }
+    else if (days.size >= 3) {
+        verdict = "went quiet";
+        says = `${messages_prev_21d} messages on ${days.size} days in the three weeks before, none this week${seenSays}`;
+    }
+    else if (age < 7) {
+        verdict = "new";
+        says = `set up ${age}d ago${messages.length ? "" : ", no message yet"}`;
+    }
+    else if (messages.length === 0 && age < 28) {
+        verdict = "never started";
+        says = `set up ${age}d ago, not one message${seenSays}`;
+    }
+    else {
+        verdict = "idle";
+        const since = last_message ?? last_seen;
+        says = since === null ? "nothing on record" : `quiet for ${daysAgo(since, now)}d${seenSays}`;
+    }
+    return {
+        name: input.name, verdict, says, members: admitted.length, online: input.online,
+        messages_7d, messages_prev_21d, active_days_prev_21d: days.size, last_message, last_seen, versions, behind,
+    };
+}
+export function fleetReport(rows, relayPkg, now = Date.now()) {
+    const date = new Date(now).toISOString().slice(0, 10);
+    const counts = VERDICT_ORDER.map((v) => [v, rows.filter((r) => r.verdict === v).length]).filter(([, n]) => n > 0);
+    const lines = [
+        `pantheon relay ${relayPkg} — the week to ${date}`,
+        `${rows.length} space${rows.length === 1 ? "" : "s"}${counts.map(([v, n]) => ` · ${n} ${v}`).join("")}`,
+    ];
+    const sorted = [...rows].sort((a, b) => VERDICT_ORDER.indexOf(a.verdict) - VERDICT_ORDER.indexOf(b.verdict) || b.messages_7d - a.messages_7d || a.name.localeCompare(b.name));
+    const width = Math.max(4, ...sorted.map((r) => r.name.length));
+    for (const r of sorted)
+        lines.push(`${r.verdict.padEnd(13)} ${r.name.padEnd(width)}  ${r.says}`);
+    const builds = {};
+    const behind = [];
+    for (const r of rows) {
+        for (const [v, n] of Object.entries(r.versions))
+            builds[v] = (builds[v] ?? 0) + n;
+        for (const b of r.behind)
+            behind.push(`${b.member} in ${r.name} on ${b.pkg}, ${b.days}d ago`);
+    }
+    const spread = Object.keys(builds).sort((a, b) => (versionBehind(a, b) ? 1 : versionBehind(b, a) ? -1 : 0)).map((v) => `${v} ×${builds[v]}`).join(" · ");
+    if (spread)
+        lines.push(`builds in use: ${spread}${behind.length ? `  (behind the relay: ${behind.join("; ")})` : ""}`);
+    return lines.join("\n");
+}
 //# sourceMappingURL=admin-stats.js.map

package/dist/cli.js

@@ -7,13 +7,13 @@ process.emitWarning = ((warning, ...rest) => {
     return _emitWarning(warning, ...rest);
 });
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
-import { fromInvite, load, save, toInvite, toJoinLink, resolveFor, loadAll, repoInfo, bindRepo, findMembership, setDefaultSpace, removeMembership, configFor, CONFIG_DIR, CONFIG_PATH, DEFAULT_RELAY, resolveForHook } from "./config.js";
+import { fromInvite, looksLikeInviteCode, resolveInviteCode, load, save, toInvite, toJoinLink, resolveFor, loadAll, repoInfo, bindRepo, findMembership, setDefaultSpace, removeMembership, configFor, CONFIG_DIR, CONFIG_PATH, DEFAULT_RELAY, resolveForHook } from "./config.js";
 import { fmtLimit } from "./plans.js";
 import { validEmail, validUsername } from "./accounts.js";
-import { install, launcher } from "./install.js";
+import { install, launcher, installForUser, removeCodexUserScope } from "./install.js";
 import { Relay } from "./relay.js";
 import { runMcp } from "./mcp.js";
 import { Worker } from "./worker.js";
@@ -22,7 +22,8 @@ import { desktopUnavailable, hostEnv } from "./host-env.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 { doctor, render, shareBlock } from "./doctor.js";
+import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { menubarProc, notifierProc, relayProc, workerProc, wiring, logFileFor, dataSummary, stopProc, statFile } from "./machine.js";
 import { assess } from "./untrusted.js";
 import { report as spendReport, recentRuns } from "./spend.js";
@@ -500,7 +501,7 @@ ${B("control")}
   pantheon spend              woken runs on this machine, and what pantheon cannot see
   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 doctor [--share]   check this machine end to end; --share prints it without names or paths, to paste to us
   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.
@@ -727,7 +728,7 @@ async function main() {
             return;
         }
         case "join": {
-            const invite = argv[1] ?? die("usage: pantheon join <invite>   (pantheons://host/space#token, or https://www.joinpantheon.network/join/<team>#<token>)  [setup answers as flags — pantheon setup --questions]");
+            const invite = argv[1] ?? die("usage: pantheon join <invite>   (pantheons://host/space#token, https://www.joinpantheon.network/join/<team>#<token>, or just the code)  [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");
@@ -736,7 +737,11 @@ async function main() {
                 parsed = fromInvite(invite);
             }
             catch (e) {
-                die(e.message);
+                if (!looksLikeInviteCode(invite))
+                    die(e.message);
+                const candidates = [flag("relay"), process.env.PANTHEON_RELAY, load()?.relay, DEFAULT_RELAY].filter((r) => !!r);
+                parsed = await resolveInviteCode(invite, candidates).catch((err) => die(err.message.replace(/^INVITE_CODE_[A-Z]+:\s*/, "")));
+                console.error(D(`That was just the code — it opens "${parsed.space}" on ${new URL(parsed.relay).host}. Joining that team.\n`));
             }
             if (!load()?.account && sameHost(parsed.relay, DEFAULT_RELAY)) {
                 die(`sign in first — this relay verifies email.\n  New here:        pantheon signup --email you@work.com --username you\n  Have an account: pantheon login  --email you@work.com\n  Then run this same \`pantheon join\` command again — the invite is still good.`);
@@ -810,6 +815,16 @@ async function main() {
             console.error(`\n${B("Restart your agent")}, then ask it: "check pantheon_status and introduce yourself to the team".`);
             return;
         }
+        case "rewire": {
+            const rows = installForUser().map((t) => ({ tool: t.tool, status: t.status }));
+            if (argv.includes("--json")) {
+                console.log(JSON.stringify(rows));
+                return;
+            }
+            for (const r of rows)
+                console.error(`  ${r.tool.padEnd(14)}${r.status}`);
+            return;
+        }
         case "upgrade": {
             const { upgrade } = await import("./upgrade.js");
             console.error(`${B("pantheon upgrade")}\n`);
@@ -1603,6 +1618,11 @@ async function main() {
             const { revokeToolPermissions } = await import("./grants.js");
             for (const l of revokeToolPermissions())
                 console.error(`  perms:${l}`);
+            {
+                const l = removeCodexUserScope();
+                if (l)
+                    console.error(`  perms:${l}`);
+            }
             const { unlinkSync, existsSync: exists, rmSync } = await import("node:fs");
             if (cfg && exists(CONFIG_PATH)) {
                 if (argv.includes("--keep-identity")) {
@@ -1620,12 +1640,13 @@ async function main() {
             else {
                 console.error(`  config: none to remove`);
             }
-            console.error(`\n  ${D("Not touched: the MCP entry in your agent (pantheon install wrote it; remove it there),")}`);
-            console.error(`  ${D("the relay's ledger on disk, and anything you pushed to git.")}`);
+            console.error(`\n  ${D("Not touched: the MCP entries in Claude Code and Cursor (pantheon install wrote them; remove them there),")}`);
+            console.error(`  ${D("the relay's ledger on disk, and anything you pushed to git. Codex's entry and approval line were removed above.")}`);
             if (cfg) {
                 console.error(`\n  ${D(`Your teammates still list you in "${cfg.space}". Ask one of them to run:`)}`);
                 console.error(`  ${D(`pantheon admit ${cfg.member} --revoke`)}`);
             }
+            console.error(`\n  ${D(`If Pantheon let you down, one line on why to ${FEEDBACK_ADDRESS} would help more than you might think.`)}`);
             return;
         }
         case "spend": {
@@ -2201,6 +2222,46 @@ async function main() {
                     hud = null;
                 }
             }
+            if (hud?.action === "fix") {
+                const dir = hud.dir && existsSync(hud.dir) ? hud.dir : process.cwd();
+                const steps = hud.lines ?? [];
+                console.error(`${B("What stopped it")}\n  ${hud.why ?? "(not recorded)"}\n`);
+                console.error(`${B("Where")}  ${dir}\n`);
+                if (!steps.length) {
+                    console.error(D("Nothing to run from here."));
+                    return;
+                }
+                console.error(B("Steps"));
+                for (const l of steps)
+                    console.error(`  ${C(l)}`);
+                if (!process.stdin.isTTY)
+                    return;
+                const rl = createInterface({ input: process.stdin, output: process.stderr });
+                try {
+                    const answer = (await new Promise((res) => rl.question(`\n${D("run these here now? [y/N] ")}`, res))).trim().toLowerCase();
+                    if (answer !== "y" && answer !== "yes") {
+                        console.error(D("left for you — the commands are above"));
+                        return;
+                    }
+                    const { spawnSync } = await import("node:child_process");
+                    for (const line of steps) {
+                        const cmd = line.replace(/\s+#.*$/, "").trim();
+                        if (!cmd)
+                            continue;
+                        console.error(D(`\n$ ${cmd}`));
+                        const r = spawnSync("sh", ["-lc", cmd], { cwd: dir, stdio: "inherit" });
+                        if (r.status !== 0) {
+                            console.error(`\n${B("stopped")} — "${cmd}" exited ${r.status}. The rest is yours.`);
+                            return;
+                        }
+                    }
+                    console.error(`\n${B("done")} — if that was the blocker, the next run can finish.`);
+                }
+                finally {
+                    rl.close();
+                }
+                return;
+            }
             if (hud?.action === "done") {
                 const c2 = new PantheonClient(cfg, undefined, { role: "cli" });
                 await c2.connect().catch((e) => die(e.message));
@@ -2576,8 +2637,14 @@ async function main() {
         }
         case "doctor": {
             const dir = resolve(flag("project", "."));
-            console.log(`${B("pantheon doctor")}  ${D(dir)}\n`);
+            const share = argv.includes("--share");
+            if (!share)
+                console.log(`${B("pantheon doctor")}  ${D(dir)}\n`);
             const checks = await doctor(dir);
+            if (share) {
+                console.log(shareBlock(checks));
+                process.exit(checks.some((c) => c.level === "fail") ? 1 : 0);
+            }
             const { text, failed } = render(checks);
             console.log(text);
             process.exit(failed ? 1 : 0);

package/dist/client.js

@@ -72,6 +72,8 @@ export class PantheonClient {
         }
     }
     connect() {
+        if (!this.everConnected)
+            this.closed = false;
         return this.attempt(this.localOverride ?? this.cfg.relay).catch(async (e) => {
             if (this.localOverride)
                 throw e;

package/dist/config.js

@@ -305,4 +305,32 @@ export function fromInvite(invite) {
         token,
     };
 }
+export const INVITE_CODE = /^[A-Za-z0-9_-]{16,64}$/;
+export const looksLikeInviteCode = (s) => INVITE_CODE.test(s.trim().replace(/^['"`]|['"`]$/g, ""));
+export async function resolveInviteCode(code, relays, fetchImpl = fetch) {
+    const token = code.trim().replace(/^['"`]|['"`]$/g, "");
+    const tried = [...new Set(relays.map((r) => r.replace(/\/+$/, "")).filter(Boolean))];
+    let answered = false;
+    for (const relay of tried) {
+        const http = relay.replace(/^ws/, "http");
+        try {
+            const res = await fetchImpl(`${http}/join?token=${encodeURIComponent(token)}`, { signal: AbortSignal.timeout(6_000) });
+            if (res.status === 404) {
+                answered = true;
+                continue;
+            }
+            if (!res.ok)
+                continue;
+            const body = (await res.json());
+            if (typeof body.team === "string" && body.team)
+                return { relay, space: body.team, token };
+        }
+        catch { }
+    }
+    const hosts = tried.map((r) => new URL(r).host).join(", ");
+    if (answered) {
+        throw new Error(`INVITE_CODE_UNKNOWN: that is an invite code, but no open invite on ${hosts} matches it — it may have been used already or expired (they last 24 hours).\n  Ask your teammate for a fresh one: pantheon invite`);
+    }
+    throw new Error(`INVITE_CODE_UNREACHABLE: that looks like an invite code, but ${hosts} could not be asked which team it opens.\n  Paste the whole invite line instead:  pantheon join https://www.joinpantheon.network/join/<team>#${token}`);
+}
 //# sourceMappingURL=config.js.map

package/dist/decision-ui.js

@@ -1,16 +1,38 @@
 const oneLine = (value) => value.replace(/\s+/g, " ").trim();
+const LAYERS = [
+    /^([a-z0-9._-]+)\s+escalated\s*:\s*/i,
+    /^([a-z0-9._-]+)\s+needs? a decision\s*:\s*/i,
+    /^([a-z0-9._-]+)\s+(?:asked|asks|said|says|wrote|reported)\s*:\s*/i,
+    /^([a-z0-9._-]+)\s+is\s+(?:asking|saying|reporting)(?:\s+that)?\s*:\s*/i,
+    /^decision (?:for|required for|needed from)\s+(?:you|[a-z0-9._-]+)\s*(?:\([^)]*\))?\s*[:—-]\s*/i,
+    /^(?:action|input|answer|decision)\s+(?:required|needed)\s*(?:\([^)]*\))?\s*(?:from|for)?\s*(?:you|[a-z0-9._-]+)?\s*[:—-]\s*/i,
+    /^needs (?:you|your input|a human)[,:]?\s*([a-z0-9._-]*)\s*[:—-]\s*/i,
+    /^human (?:action|input) required\s*[—:-]?\s*/i,
+];
+export function stripCeremony(body) {
+    let text = oneLine(body);
+    let from;
+    for (let round = 0; round < 6; round++) {
+        const before = text;
+        for (const re of LAYERS) {
+            const m = re.exec(text);
+            if (!m)
+                continue;
+            const name = (m[1] ?? "").trim();
+            if (!from && name && !/^(you|your|a)$/i.test(name))
+                from = name.toLowerCase();
+            text = text.slice(m[0].length);
+        }
+        if (text === before)
+            break;
+    }
+    return { text: text.trim(), ...(from ? { from } : {}) };
+}
 export function decisionTitle(body, max = 96) {
-    let text = oneLine(body)
-        .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(/^needs (?:you|your input|a human)[,:]?\s*[a-z0-9._-]*\s*[:—-]\s*/i, "")
-        .replace(/\(goal\s+g_[a-z0-9]+\s*,\s*/gi, "(")
+    let text = stripCeremony(body).text
+        .replace(/\(\s*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) {