@join-pantheon/cli 0.18.2 → 0.19.1

package/README.md

@@ -28,8 +28,7 @@ npm install -g @join-pantheon/cli
 Or run it without installing at all:
 
 ```bash
-npx @join-pantheon/cli start          # you
-npx @join-pantheon/cli join <invite>  # them
+npx @join-pantheon/cli                # guided sign-in; it tells you what to run next
 ```
 
 **First, verify your email (once per person):**
@@ -55,9 +54,13 @@ pantheon start
 **Your teammate, from their clone of the project:**
 
 ```bash
-pantheon join pantheon://100.92.14.7:8787/acme#C1qhJfdHBaPjuG3jF48vcqrP
+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`).
+
 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,
 every Conductor window, nothing to commit), the wake-up hook so an agent finishes what a peer is
@@ -88,7 +91,10 @@ Need another (a third person, or your own second machine)? `pantheon invite`.
 
 ### Reaching each other across cities
 
-`pantheon start` works this out for you. If Tailscale is running it uses your tailnet address, which
+On the hosted relay there is nothing to work out: every signed-in machine dials
+`relay.joinpantheon.network`. The rest of this section is for **self-hosting** (`pantheon start
+--relay …`, or a machine with no account). Then `pantheon start` runs a relay on your machine and
+works out where a teammate can reach it. If Tailscale is running it uses your tailnet address, which
 is private and needs no TLS. Otherwise it tells you the address is local-only and how to fix it:
 
 ```
@@ -114,7 +120,7 @@ internet, and whether you were actually admitted. Non-zero exit means don't star
 <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`
-· `pantheon install` (project-scope, needs `npm link` and a commit). Membership by explicit
+· `pantheon install` (project-scope: commits a `.mcp.json`, so `pantheon` must be on PATH). Membership by explicit
 allowlist with fingerprint confirmation, rather than by invite. Everything the two-command path
 does, one step at a time.
 
@@ -222,7 +228,7 @@ Human decisions use a separate, model-free path. `ESCALATE` creates a durable
 ```sh
 pantheon service install notifier        # starts at login; no wake permission needed
 pantheon profile set --surface codex      # codex | claude-code | cursor
-pantheon profile set --name "Praneet" --title "Co-founder & CEO" \
+pantheon profile set --name "Alex" --title "Head of Product" \
   --responsibilities product-ui,gtm,marketing \
   --human-required product-ui,gtm,marketing
 pantheon directory                        # shared responsibility and authority graph
@@ -249,7 +255,8 @@ local. Before a consequential decision, agents call `pantheon_route_decision`
 with explicit domains. Matching `human_required` owners receive separate
 `HUMAN_REQUIRED` acts; matching `agent_can_decide` owners may answer through
 their delegate. Missing authority fails closed and escalates to the caller's
-human. See [Pantheon / Pantheon V1 acceptance](docs/PANTHEON_V1_ACCEPTANCE.md).
+human. The security model is written up at
+[joinpantheon.network/security](https://www.joinpantheon.network/security).
 
 Delegation is one hop, time-bounded, and preserves the original authority
 level: a human-only decision cannot become agent-decidable through delegation.
@@ -312,7 +319,7 @@ dead air on an unattended machine. And the worker finally says what it is doing:
 and cap refusal is logged with its reason, and `worker-state.json` feeds the same line to
 `pantheon ps` and the menu bar.
 
-Proven by team-shaped tests (`team-flow.test.ts`): a full unattended round trip where the asking
+Proven by end-to-end tests with real workers and a real relay: a full unattended round trip where the asking
 session closes before the reply and both workers finish the goal anyway; deliver→review→accept
 with no human; the cap and lock governors under two workers per member.
 
@@ -328,12 +335,11 @@ the same "no shell unless you said so" rule spelled in its own dialect:
 | codex | `--sandbox read-only` (codex has no edits-without-shell mode) | `--sandbox workspace-write` |
 | cursor | proposes edits, never applies (`-p` without `--force`) | `--force` |
 
-Claude Code and Cursor are verified with **real live woken runs** (see `live-smoke.test.ts`;
-`PANTHEON_LIVE_SMOKE=1 PANTHEON_LIVE_BACKEND=cursor …`). The codex invocation is built against the
-verified `codex exec` surface but has not yet run against a real codex install — smoke it on a
-machine that has one before leaning on it. Note codex quirks the tooling handles for you: no
-per-run approval flag exists in exec, MCP arrives via `-c` overrides (a worktree `.codex/` is
-ignored), and codex silently skips a newly installed hook until you approve it with `/hooks`.
+All three backends are verified with **real live woken runs** — an idle machine answering a
+peer's ASK end to end with Claude Code, Cursor, and Codex. Codex quirks the tooling handles for
+you: no per-run approval flag exists in `codex exec`, MCP arrives via `-c` overrides (a worktree
+`.codex/` is ignored), and codex silently skips a newly installed hook until you approve it with
+`/hooks`.
 
 ### Personas — telling the worker who to be
 
@@ -401,19 +407,25 @@ on each laptop; what crosses the wire is acts, contracts, diff summaries and dec
 ## Commands
 
 ```
-pantheon relay      run the coordination plane
-pantheon init       claim a space, print an invite
-pantheon join       join a colleague's space
-pantheon install    wire the MCP server into claude code / cursor / conductor here
-pantheon status     who's online, open goals, what you owe
-pantheon watch      live tail of everything the delegates say to each other
-pantheon persona    list / init / show — what a woken worker may do and how it behaves
-pantheon say        send an act by hand (kick things off, or debug)
-pantheon mcp        the stdio MCP server — your agent runs this, not you
+pantheon signup / verify / login   verify your email once; sign a second machine in
+pantheon start                     create your team on the hosted relay, get the line to send
+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 worker / service          stay answerable while you are away (install as a service)
+pantheon persona                   list / init / show — what a woken worker may do
+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
+pantheon relay                     run your own relay (self-hosting)
+pantheon mcp                       the stdio MCP server — your agent runs this, not you
 ```
 
-`pantheon watch` is how a human stays oriented without being in the loop. Every act is also
-appended to `pantheon-data/<space>.jsonl`, so the full history is replayable with `tail`.
+`pantheon help --all` lists everything. `pantheon watch` is how a human stays oriented without
+being in the loop; every act is also appended to the relay's ledger, so the full history is
+replayable.
 
 ## What this still is not
 
@@ -429,10 +441,29 @@ appended to `pantheon-data/<space>.jsonl`, so the full history is replayable wit
 - **A woken run is trusted with your repo.** `--allow-bash` in particular means a peer's request
   can execute commands on your machine. Grant `--may-wake` deliberately.
 
-## Tests
+## Privacy, data, and support
+
+The hosted relay at `relay.joinpantheon.network` holds only what coordination needs: your
+verified email, username, and device public keys; the IPs and timestamps of your sessions and
+an audit trail of identity and membership events; and, per space, the acts your delegates
+exchanged plus open goals and obligations. Your code, credentials, and repo never leave your
+machine — the relay has no filesystem or shell access by design.
+
+- `pantheon sessions` shows every device and session on your account; `revoke` signs one out.
+- `pantheon audit` is your own trail; `pantheon account delete` removes your account, devices,
+  sessions, and memberships.
+- Prefer to run your own? `pantheon relay` is the whole server; point machines at it with
+  `pantheon start --relay wss://your-host`. Accounts are optional there.
+
+Security details and how to report a vulnerability:
+[joinpantheon.network/security](https://www.joinpantheon.network/security). Everything else:
+[joinpantheon.network](https://www.joinpantheon.network).
+
+## Upgrading
 
 ```bash
-npm run build
-node --test dist/test/fabric.test.js   # protocol, obligations, guards, auth, claims, durability
-node --test dist/test/mcp.test.js      # real stdio JSON-RPC against the MCP server
+pantheon upgrade          # installs the latest release and re-wires your agents
 ```
+
+Every command prints its version and nudges you when a newer release exists. Restart your agent
+session after upgrading so it loads the new MCP server.

package/dist/cli.js

@@ -89,12 +89,14 @@ async function interactiveOnboard(relayArg) {
         }
         let started = null;
         let mode = "signup";
+        let signupUsername = "";
         while (!started || started.status !== 200) {
             const u = await ask("  Pick a username: ");
             if (!validUsername(u.toLowerCase())) {
                 console.error(D("    2–32 chars: letters, digits, . _ - (not at the ends)"));
                 continue;
             }
+            signupUsername = u;
             started = await postJson("/auth/signup", { email, username: u, pubkey: kp.publicKey, label }).catch((e) => { console.error(D(`    could not reach the relay: ${e.message}`)); return null; });
             if (!started)
                 return;
@@ -117,15 +119,28 @@ async function interactiveOnboard(relayArg) {
             console.error(D(`  ${started?.j.error ?? "sign-up failed"}`));
             return;
         }
-        const via = started.j.via === "resend" ? "" : `\n  ${D("(this is a dev relay — your code is printed in its log)")}`;
-        console.error(`\n  ${C("Sent a 6-digit code")} to ${B(email)}. Check your inbox.${via}\n`);
+        const authUser = mode === "signup" ? signupUsername : undefined;
+        save({ ...(prior ?? {}), relay, member: signupUsername || prior?.member || "me",
+            space: prior?.space ?? "", token: prior?.token ?? "",
+            publicKey: kp.publicKey, privateKey: kp.privateKey, agent: prior?.agent ?? "unknown",
+            pendingAuth: { email, ...(authUser ? { username: authUser } : {}), purpose: mode } });
+        if (started.j.sent === false && started.j.via === "resend") {
+            console.error(`\n  ${D("The relay could not send the email just now.")} Type 'resend' to retry, or run ${C("pantheon")} again shortly.\n`);
+        }
+        else {
+            const via = started.j.via === "resend" ? "" : `\n  ${D("(this is a dev relay — your code is printed in its log)")}`;
+            console.error(`\n  ${C("Sent a 6-digit code")} to ${B(email)}. Check your inbox.${via}\n`);
+        }
         for (let attempt = 0; attempt < 6; attempt++) {
             const code = await ask("  Enter the code (or 'resend'): ");
             if (/^resend$/i.test(code)) {
-                await postJson(mode === "signup" ? "/auth/signup" : "/auth/login", mode === "signup"
-                    ? { email, username: prior?.member, pubkey: kp.publicKey, label }
-                    : { email, pubkey: kp.publicKey, label });
-                console.error(D("    sent a fresh code."));
+                const rs = await postJson(mode === "signup" ? "/auth/signup" : "/auth/login", mode === "signup"
+                    ? { email, username: signupUsername, pubkey: kp.publicKey, label }
+                    : { email, pubkey: kp.publicKey, label }).catch(() => null);
+                if (rs && rs.status === 200 && rs.j.sent !== false)
+                    console.error(D("    sent a fresh code."));
+                else
+                    console.error(D(`    could not resend: ${rs?.j.error ?? "the relay did not send an email"} — try again in a minute.`));
                 continue;
             }
             const v = await postJson("/auth/verify", { email, code });
@@ -195,8 +210,16 @@ function die(msg) {
     console.error(`pantheon: ${msg}`);
     process.exit(1);
 }
+function sameHost(a, b) {
+    try {
+        return new URL(a).host === new URL(b).host;
+    }
+    catch {
+        return false;
+    }
+}
 function need() {
-    return load() ?? die("not configured. Run `pantheon init` (first machine) or `pantheon join <invite>` (other machines).");
+    return load() ?? die("not configured. Run `pantheon signup` then `pantheon start` (create a team), or `pantheon join <invite>` (join one).");
 }
 function printGranted(granted) {
     if (!granted.length)
@@ -303,7 +326,8 @@ ${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, ...)
-  pantheon init / install     the step-by-step setup path, instead of \`start\`
+  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
   pantheon limits             the guard values in force
   pantheon version            the pantheon version this machine is running
@@ -350,6 +374,12 @@ async function main() {
             for (const w of r.warnings)
                 console.error(`\x1b[33m  ! ${w}\x1b[0m`);
             printGranted(r.granted);
+            if (!r.claimed) {
+                console.error(`\n\x1b[31m  No team was created.\x1b[0m ${D("Fix the warning above, then run `pantheon start` again.")}`);
+                if (r.relay)
+                    await r.relay.close().catch(() => { });
+                process.exit(1);
+            }
             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`);
@@ -391,6 +421,21 @@ async function main() {
             console.error(D(`health:     http://localhost:${port}/health`));
             console.error(D(`\nFor a colleague on another network, expose this port (ssh -R, cloudflared, tailscale)`));
             console.error(D(`and hand them the invite from \`pantheon init\`. Ctrl-C to stop.`));
+            let shuttingDown = false;
+            const shutdown = async (sig) => {
+                if (shuttingDown)
+                    return;
+                shuttingDown = true;
+                console.error(D(`\n${sig} — flushing state and closing…`));
+                try {
+                    await relay.close();
+                }
+                catch { }
+                process.exit(0);
+            };
+            process.on("SIGTERM", () => void shutdown("SIGTERM"));
+            process.on("SIGINT", () => void shutdown("SIGINT"));
+            await new Promise(() => { });
             return;
         }
         case "init": {
@@ -443,6 +488,9 @@ async function main() {
             catch (e) {
                 die(e.message);
             }
+            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.`);
+            }
             const wp = unattendedProject();
             console.error(`${B("pantheon join")}\n`);
             const r = await qsJoin({
@@ -553,7 +601,7 @@ async function main() {
             console.log(`${B(cfg.space)}  you are ${C(cfg.member)}  ${D(cfg.relay)}  ${D(`${client.head} acts`)}\n`);
             console.log(B("members"));
             if (!peers.length)
-                console.log(`  ${D("(nobody else yet — send them the invite from `pantheon init`)")}`);
+                console.log(`  ${D("(nobody else yet — send them an invite from `pantheon invite`)")}`);
             for (const p of peers) {
                 const behind = p.seen_seq === undefined ? null : client.head - p.seen_seq;
                 const reach = behind === null
@@ -1275,6 +1323,11 @@ async function main() {
             save({ ...(prior ?? {}), relay, member: username ?? prior?.member ?? "me", space: prior?.space ?? "", token: prior?.token ?? "",
                 publicKey: kp.publicKey, privateKey: kp.privateKey, agent: prior?.agent ?? "unknown",
                 pendingAuth: { email, ...(username ? { username } : {}), purpose } });
+            if (r.j.sent === false && r.j.via === "resend") {
+                console.error(`${B("signup accepted, but the email could not be sent just now.")}`);
+                console.error(`Retry in a minute:  ${C(`pantheon ${purpose} --email ${email}${username ? ` --username ${username}` : ""}`)}`);
+                return;
+            }
             const via = r.j.via === "resend" ? "" : D("  (dev relay: the code is in the relay log)");
             console.error(`${B("check your email")} — we sent a 6-digit code to ${C(email)}.${via}`);
             console.error(`Then run:  ${C("pantheon verify <code>")}`);

package/dist/client.js

@@ -57,7 +57,7 @@ export class PantheonClient {
             return null;
         const port = u.port || "8787";
         try {
-            const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(1200) });
+            const res = await fetch(`http://127.0.0.1:${port}/health?space=${encodeURIComponent(this.cfg.space)}`, { signal: AbortSignal.timeout(1200) });
             const body = (await res.json());
             if (!body.spaces?.some((sp) => sp.name === this.cfg.space))
                 return null;

package/dist/doctor.js

@@ -42,9 +42,9 @@ export async function doctor(projectDir) {
     const out = [];
     const add = (level, name, detail, fix) => out.push({ level, name, detail, ...(fix ? { fix } : {}) });
     const major = Number(process.versions.node.split(".")[0]);
-    major >= 20
+    major >= 22
         ? add("pass", "node", `v${process.versions.node}`)
-        : add("fail", "node", `v${process.versions.node} is too old`, "install Node 20 or newer");
+        : add("fail", "node", `v${process.versions.node} is too old`, "pantheon needs Node 22 or newer (the relay uses node:sqlite) — install it and re-run");
     let cfg = null;
     try {
         cfg = load();
@@ -53,7 +53,7 @@ export async function doctor(projectDir) {
         add("fail", "config", `unreadable: ${e.message}`);
     }
     if (!cfg) {
-        add("fail", "config", "no config found", "run `pantheon init` (first machine) or `pantheon join <invite>` (other machines)");
+        add("fail", "config", "no config found", "run `pantheon signup` (new here) then `pantheon start` (create a team), or `pantheon join <invite>` (join one)");
         return out;
     }
     add("pass", "config", `${cfg.member} in "${cfg.space}" via ${cfg.relay}  (${CONFIG_PATH})`);
@@ -79,12 +79,12 @@ export async function doctor(projectDir) {
             add("pass", "mcp entry", "portable (`pantheon mcp`) — safe to commit, works on your teammate's machine");
         }
         else {
-            add("fail", "mcp entry", `hard-codes this machine: ${entry.command}`, "run `npm link` in the pantheon repo, then `pantheon install` again. Committed as-is it silently fails on the other machine — the MCP server never starts and no error is shown.");
+            add("fail", "mcp entry", `hard-codes this machine: ${entry.command}`, "make sure `pantheon` is on your PATH, then run `pantheon install` again — it writes the portable `pantheon mcp` entry. Committed as-is it silently fails on the other machine: the MCP server never starts and no error is shown.");
         }
     }
     onPath()
         ? add("pass", "PATH", "`pantheon` resolves by name")
-        : add("warn", "PATH", "`pantheon` is not on PATH", "run `npm link` in the pantheon repo");
+        : add("warn", "PATH", "`pantheon` is not on PATH", "install it globally (`npm install -g @join-pantheon/cli`) and make sure your npm global bin dir (`npm bin -g`) is on PATH");
     const inRepo = sh("git rev-parse --is-inside-work-tree", projectDir) === "true";
     if (!inRepo) {
         add("warn", "git", `${projectDir} is not a git repo`, "DELIVERED requires a pushed branch + commit, so the work needs to live in a repo you both clone");
@@ -151,7 +151,7 @@ export async function doctor(projectDir) {
     admittedPeers.length
         ? add("pass", "peers", admittedPeers
             .map((p) => `${p.member}[${online.has(p.member) ? "online" : "no session open"}]`).join("  "))
-        : add("warn", "peers", "nobody else is admitted to this space yet", "send your teammate the invite from `pantheon init`, then admit them with `pantheon admit <them> --may-wake`");
+        : add("warn", "peers", "nobody else is admitted to this space yet", "send your teammate an invite from `pantheon invite` (or the one `pantheon start` printed)");
     if (pending.length) {
         add("warn", "pending", pending.map((p) => `${p.member} (${p.fingerprint})`).join("  "), `confirm the fingerprint by voice, then: pantheon admit ${pending[0].member} --may-wake`);
     }

package/dist/install.js

@@ -115,7 +115,8 @@ export function install(projectDir, cfg, force) {
         out.push("  machine's node binary and checkout path. It works here and silently fails on any");
         out.push("  other machine — the MCP server just never starts, with no error.");
         out.push("");
-        out.push("  Fix it before committing:   \x1b[1mnpm link\x1b[0m   (in the pantheon repo), then re-run `pantheon install`");
+        out.push("  Fix it before committing:   install pantheon globally (\x1b[1mnpm install -g @join-pantheon/cli\x1b[0m)");
+        out.push("                              and put your npm global bin (`npm bin -g`) on PATH, then re-run `pantheon install`");
         out.push("  Or keep it local-only:      add .mcp.json to .gitignore and have your teammate run");
         out.push("                              `pantheon install` on their own machine instead.");
     }
@@ -127,13 +128,18 @@ function localEntry() {
 function userEntry() {
     try {
         const abs = execFileSync("sh", ["-lc", "command -v pantheon"], { encoding: "utf8" }).trim();
-        if (abs)
+        if (abs && !isVersionManagedPath(abs))
             return { command: abs, args: ["mcp"] };
+        if (abs)
+            return { command: "pantheon", args: ["mcp"] };
     }
     catch { }
     const l = launcher();
     return { command: l.command, args: l.args };
 }
+function isVersionManagedPath(p) {
+    return /[\/\\]\.nvm[\/\\]versions[\/\\]node[\/\\]|[\/\\]\.fnm[\/\\]|[\/\\]\.asdf[\/\\]installs[\/\\]nodejs[\/\\]|[\/\\]n[\/\\]versions[\/\\]node[\/\\]|[\/\\]\.volta[\/\\]tools[\/\\]/.test(p);
+}
 function claudeUserScope(entry) {
     const tool = "claude code";
     try {

package/dist/notifier.js

@@ -53,10 +53,19 @@ export function ensureNativeNotifier(home = CONFIG_DIR) {
         throw new Error(`Pantheon notification helper source is missing: ${source}`);
     const binary = hudBinaryPath(home);
     mkdirSync(dirname(binary), { recursive: true });
+    requireDeveloperTools("notifications", "notifier");
     execFileSync("/usr/bin/swiftc", ["-O", source, "-o", binary], { stdio: "pipe" });
     chmodSync(binary, 0o755);
     return binary;
 }
+export function requireDeveloperTools(what, service) {
+    try {
+        execFileSync("/usr/bin/xcode-select", ["-p"], { stdio: "pipe" });
+    }
+    catch {
+        throw new Error(`building ${what} needs the Xcode Command Line Tools — run \`xcode-select --install\`, then \`pantheon service install ${service}\``);
+    }
+}
 export function sendDesktopNotification(title, subtitle, body, profile, prompt = "", eyebrow = "Decision needed") {
     if (platform() !== "darwin")
         return false;

package/dist/quickstart.js

@@ -3,7 +3,7 @@ import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { homedir } from "node:os";
 import { PantheonClient } from "./client.js";
-import { load, save, toInvite } from "./config.js";
+import { load, save, toInvite, DEFAULT_RELAY } from "./config.js";
 import { newKeypair } from "./identity.js";
 import { installForUser } from "./install.js";
 import { writeIntent, installHooks } from "./notify.js";
@@ -131,12 +131,15 @@ export function findReach(port) {
 }
 export async function start(opts) {
     const warnings = [];
-    const reach = opts.relay
-        ? (/127\.0\.0\.1|localhost|\[::1\]/.test(opts.relay)
-            ? { url: opts.relay, how: "as given", shareable: false,
+    const priorCfg = load();
+    const signedInRelay = priorCfg?.account ? (priorCfg.relay ?? DEFAULT_RELAY) : undefined;
+    const chosen = opts.relay ?? signedInRelay;
+    const reach = chosen
+        ? (/127\.0\.0\.1|localhost|\[::1\]/.test(chosen)
+            ? { url: chosen, how: "as given", shareable: false,
                 hint: `That address is this machine only — a teammate cannot reach it.\n` +
                     `  Use a tailnet address (tailscale ip -4) or a tunnel, then re-run pantheon start.` }
-            : { url: opts.relay, how: "as given", shareable: true })
+            : { url: chosen, how: opts.relay ? "as given" : "your signed-in relay", shareable: true })
         : findReach(opts.port);
     let relay = null;
     const health = reach.url.replace(/^ws/, "http") + "/health";
@@ -149,11 +152,11 @@ export async function start(opts) {
         await relay.listen();
         opts.log(`  relay      started on ${reach.url}  (${reach.how})`);
     }
-    const existing = load();
+    const existing = priorCfg;
     const hasOwnSpace = !!existing?.space && !!existing?.token;
     const reuse = !!existing && !opts.reset && hasOwnSpace && (!opts.space || opts.space === existing.space);
     const keepIdentity = !!existing && !opts.reset && !!existing.publicKey && !!existing.privateKey;
-    const cfg = reuse
+    let cfg = reuse
         ? { ...existing, relay: reach.url, agent: detectAgent() }
         : {
             relay: reach.url,
@@ -176,22 +179,47 @@ export async function start(opts) {
     else if (existing && existing.space) {
         warnings.push(`replacing your identity in "${existing.space}" — that space is no longer reachable from this machine`);
     }
-    const client = new PantheonClient(cfg);
     let invite = null;
+    let claimed = false;
+    const claim = async (c) => {
+        const client = new PantheonClient(c);
+        try {
+            await client.connect();
+            save(c);
+            opts.log(`  space      ${c.space} ${reuse ? "— reconnected" : "— created, you own it"}`);
+            const inv = await client.makeInvite(true, opts.ttlMinutes);
+            invite = toInvite({ ...c, token: inv.url });
+            claimed = true;
+        }
+        finally {
+            client.close();
+        }
+    };
     try {
-        await client.connect();
-        save(cfg);
-        opts.log(`  space      ${cfg.space} ${reuse ? "— reconnected" : "— created, you own it"}`);
-        const inv = await client.makeInvite(true, opts.ttlMinutes);
-        invite = toInvite({ ...cfg, token: inv.url });
+        await claim(cfg);
     }
     catch (e) {
-        warnings.push(`could not claim the space: ${e.message}`);
-        if (!reuse && existing)
-            warnings.push(`your existing config was left untouched`);
-    }
-    finally {
-        client.close();
+        const msg = e.message;
+        const nameTaken = !reuse && /BAD_TOKEN/.test(msg);
+        if (nameTaken && !opts.space) {
+            const alt = `${cfg.space}-${cfg.member}`;
+            opts.log(`  space      "${cfg.space}" is already another team's space on this relay — using "${alt}"`);
+            cfg = { ...cfg, space: alt };
+            try {
+                await claim(cfg);
+            }
+            catch (e2) {
+                warnings.push(`could not claim the space "${alt}": ${e2.message}`);
+            }
+        }
+        else if (nameTaken) {
+            warnings.push(`the name "${cfg.space}" is already another team's space on this relay — pick a different one: pantheon start --space <name>`);
+        }
+        else {
+            warnings.push(`could not claim the space: ${msg}`);
+            if (!reuse && existing)
+                warnings.push(`your existing config was left untouched`);
+        }
     }
     const wired = wireUp({
         hook: opts.hook !== false,
@@ -201,7 +229,7 @@ export async function start(opts) {
         ...(opts.workerHow ? { workerHow: opts.workerHow } : {}),
     });
     warnings.push(...wired.warnings);
-    return { cfg, invite, reach, tools: wired.tools, granted: wired.granted, relay, warnings };
+    return { cfg, invite, claimed, reach, tools: wired.tools, granted: wired.granted, relay, warnings };
 }
 export async function join(opts) {
     const existing = opts.reset ? null : load();
@@ -218,6 +246,7 @@ export async function join(opts) {
         member: opts.me ?? existing?.member ?? (process.env.USER ?? "me").toLowerCase().replace(/[^a-z0-9._-]/g, "-"),
         agent: detectAgent(),
         ...keys,
+        ...(existing?.account ? { account: existing.account } : {}),
     };
     const client = new PantheonClient(cfg, undefined, { enroll: opts.invite.token });
     await client.connect();

package/dist/relay.js

@@ -1,6 +1,7 @@
 import { createServer } from "node:http";
 import { createHash, randomBytes, timingSafeEqual as timingSafeEqualBuf } from "node:crypto";
 import { rmSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { WebSocketServer } from "ws";
 import { badRemote, Inbound, isContinuationFor, LIMITS, newId, PROTOCOL_VERSION, SENDABLE, shouldDeferToHuman, } from "./protocol.js";
@@ -78,7 +79,7 @@ export class Relay {
     dataDir;
     log;
     http = createServer((req, res) => this.onHttp(req, res));
-    wss = new WebSocketServer({ noServer: true });
+    wss = new WebSocketServer({ noServer: true, maxPayload: 256 * 1024 });
     heartbeat;
     compactedAt = new Map();
     sessionSeq = 0;
@@ -88,8 +89,11 @@ export class Relay {
     pruneMs;
     accounts;
     requireAccounts;
+    trustLocal;
     email;
     authHits = new Map();
+    adminHits = new Map();
+    emailSends = [];
     adminToken;
     backupTimer;
     constructor(opts = {}) {
@@ -97,6 +101,9 @@ export class Relay {
         this.dataDir = opts.dataDir ?? "./pantheon-data";
         this.log = opts.log ?? ((l) => console.error(l));
         this.requireAccounts = opts.requireAccounts ?? process.env.PANTHEON_REQUIRE_ACCOUNTS === "1";
+        this.trustLocal = process.env.PANTHEON_TRUST_LOCAL !== undefined
+            ? process.env.PANTHEON_TRUST_LOCAL === "1"
+            : !this.requireAccounts;
         this.adminToken = process.env.PANTHEON_ADMIN_TOKEN?.trim() || null;
         const wantStore = this.requireAccounts || this.adminToken !== null;
         this.accounts = opts.accounts ?? (wantStore ? new Accounts(join(this.dataDir, "accounts.db")) : null);
@@ -160,20 +167,26 @@ export class Relay {
             return this.onAuthHttp(req, res, url, ip);
         }
         if (url.pathname === "/health") {
+            const adminView = !!this.adminToken && this.adminTokenPresented(req, url);
+            const detail = (s) => ({
+                name: s.name,
+                members: s.members.size,
+                online: [...s.members.values()].filter((m) => m.sessions.size > 0).length,
+                sessions: [...s.members.values()].reduce((n, m) => n + m.sessions.size, 0),
+                goals: s.goals.size,
+                seq: s.ledger.head,
+            });
+            const asked = url.searchParams.get("space");
+            const one = asked ? this.spaces.get(asked) : undefined;
             return this.json(res, 200, {
                 ok: true,
                 v: PROTOCOL_VERSION,
                 pkg: VERSION,
                 space_count: this.spaces.size,
                 space_capacity: this.limits.maxSpaces,
-                spaces: [...this.spaces.values()].map((s) => ({
-                    name: s.name,
-                    members: s.members.size,
-                    online: [...s.members.values()].filter((m) => m.sessions.size > 0).length,
-                    sessions: [...s.members.values()].reduce((n, m) => n + m.sessions.size, 0),
-                    goals: s.goals.size,
-                    seq: s.ledger.head,
-                })),
+                ...(adminView ? { spaces: [...this.spaces.values()].map(detail) }
+                    : asked ? { spaces: one ? [detail(one)] : [] }
+                        : {}),
             });
         }
         if (url.pathname === "/history") {
@@ -263,7 +276,7 @@ export class Relay {
     onAuthHttp(req, res, url, ip) {
         if (url.pathname === "/")
             return this.landingPage(res);
-        if (url.pathname === "/admin" || url.pathname === "/admin/export" || url.pathname === "/admin/login" || url.pathname === "/admin/logout") {
+        if (url.pathname === "/admin" || url.pathname === "/admin/export" || url.pathname === "/admin/backup" || url.pathname === "/admin/login" || url.pathname === "/admin/logout") {
             const A0 = this.accounts;
             if (!A0 || !this.adminToken)
                 return this.json(res, 404, { error: "not found" });
@@ -271,10 +284,17 @@ export class Relay {
             const fromCookie = cookieVal(req, "pantheon_admin");
             const fromQuery = url.searchParams.get("token") ?? req.headers["authorization"]?.replace(/^Bearer\s+/i, "") ?? "";
             if (url.pathname === "/admin/login" && req.method === "POST") {
+                if (!this.adminLoginOk(ip)) {
+                    res.writeHead(429, { "content-type": "text/html; charset=utf-8", "retry-after": "60" });
+                    return void res.end("<p>Too many attempts. Wait a minute and try again.</p>");
+                }
                 return this.readForm(req, (body) => {
-                    if (!tokenOk(body.token ?? ""))
+                    if (!tokenOk(body.token ?? "")) {
+                        this.noteAdminFail(ip);
                         return this.adminLoginPage(res, true);
-                    res.writeHead(302, { "set-cookie": `pantheon_admin=${encodeURIComponent(body.token)}; HttpOnly; SameSite=Strict; Path=/admin; Max-Age=43200`, location: "/admin" });
+                    }
+                    const secure = req.headers["x-forwarded-proto"] === "https" ? "; Secure" : "";
+                    res.writeHead(302, { "set-cookie": `pantheon_admin=${encodeURIComponent(body.token)}; HttpOnly; SameSite=Strict; Path=/admin; Max-Age=43200${secure}`, location: "/admin" });
                     return void res.end();
                 });
             }
@@ -288,6 +308,11 @@ export class Relay {
                     return this.json(res, 403, { error: "sign in at /admin, or append ?token=…" });
                 return this.adminExport(res, A0, url);
             }
+            if (url.pathname === "/admin/backup") {
+                if (!authed)
+                    return this.json(res, 403, { error: "sign in at /admin, or append ?token=…" });
+                return this.adminBackup(res, A0);
+            }
             if (!authed)
                 return this.adminLoginPage(res, false);
             return this.adminDashboard(res, A0);
@@ -315,7 +340,11 @@ export class Relay {
                     return this.json(res, 409, { error: msg, reason: started.reason });
                 }
                 A.audit({ event: "signup", target: normalizeUsername(b.username), ip });
+                if (!this.emailBudgetOk())
+                    return this.json(res, 429, { error: "the relay is sending too many codes right now — try again shortly" });
                 const sent = await this.email.sendCode(b.email, started.code, "signup");
+                if (sent)
+                    this.emailSends.push(Date.now());
                 return this.json(res, 200, { ok: true, sent, via: this.email.kind });
             });
         }
@@ -331,7 +360,11 @@ export class Relay {
                     const msg = started.reason === "too_soon" ? "a code was just sent — check your email, or wait a minute" : "no active account for that email — `pantheon signup` first";
                     return this.json(res, code, { error: msg, reason: started.reason });
                 }
+                if (!this.emailBudgetOk())
+                    return this.json(res, 429, { error: "the relay is sending too many codes right now — try again shortly" });
                 const sent = await this.email.sendCode(b.email, started.code, "login");
+                if (sent)
+                    this.emailSends.push(Date.now());
                 return this.json(res, 200, { ok: true, sent, via: this.email.kind });
             });
         }
@@ -426,8 +459,48 @@ export class Relay {
             return null;
         return { account, device };
     }
+    localTrusted(ip) {
+        return this.trustLocal && isTrustedSource(ip);
+    }
+    adminTokenPresented(req, url) {
+        if (!this.adminToken)
+            return false;
+        const t = url.searchParams.get("token")
+            ?? req.headers["authorization"]?.replace(/^Bearer\s+/i, "")
+            ?? "";
+        if (!t)
+            return false;
+        const a = Buffer.from(t), b = Buffer.from(this.adminToken);
+        return a.length === b.length && timingSafeEqualBuf(a, b);
+    }
+    adminLoginOk(ip) {
+        const now = Date.now();
+        const recent = (this.adminHits.get(ip) ?? []).filter((t) => now - t < 300_000);
+        return recent.length < 10;
+    }
+    noteAdminFail(ip) {
+        const now = Date.now();
+        const recent = (this.adminHits.get(ip) ?? []).filter((t) => now - t < 300_000);
+        recent.push(now);
+        this.adminHits.set(ip, recent);
+        if (this.adminHits.size > 10_000) {
+            for (const [k, v] of this.adminHits) {
+                const live = v.filter((t) => now - t < 300_000);
+                if (live.length)
+                    this.adminHits.set(k, live);
+                else
+                    this.adminHits.delete(k);
+            }
+        }
+    }
+    emailBudgetOk() {
+        const now = Date.now();
+        this.emailSends = this.emailSends.filter((t) => now - t < 3_600_000);
+        const cap = Number(process.env.PANTHEON_EMAIL_MAX_PER_HOUR) || 200;
+        return this.emailSends.length < cap;
+    }
     authRateOk(ip) {
-        if (isTrustedSource(ip))
+        if (this.localTrusted(ip))
             return true;
         const now = Date.now();
         const recent = (this.authHits.get(ip) ?? []).filter((t) => now - t < 60_000);
@@ -579,6 +652,41 @@ button{width:100%;margin-top:12px;padding:10px;border:0;border-radius:8px;backgr
         res.writeHead(200, { "content-type": "text/csv", "content-disposition": `attachment; filename="${table}.csv"` });
         res.end(csv);
     }
+    adminBackup(res, A) {
+        try {
+            A.backup(join(this.dataDir, "backups"));
+        }
+        catch (e) {
+            this.log(`! backup snapshot before archive failed: ${e.message}`);
+        }
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const tar = spawn("tar", ["czf", "-", "-C", this.dataDir, "."], { stdio: ["ignore", "pipe", "pipe"] });
+        let err = "";
+        tar.stderr.on("data", (c) => { err += String(c); });
+        tar.on("error", (e) => {
+            this.log(`! backup archive failed to start: ${e.message}`);
+            if (!res.headersSent)
+                this.json(res, 500, { error: `could not start tar: ${e.message}` });
+        });
+        tar.stdout.once("data", () => {
+            if (!res.headersSent) {
+                res.writeHead(200, { "content-type": "application/gzip", "content-disposition": `attachment; filename="pantheon-data-${stamp}.tgz"` });
+            }
+        });
+        tar.stdout.pipe(res);
+        tar.on("close", (code) => {
+            if (code !== 0) {
+                this.log(`! backup archive exited ${code}: ${err.trim()}`);
+                if (!res.headersSent)
+                    this.json(res, 500, { error: `tar exited ${code}` });
+            }
+            res.end();
+        });
+        res.on("close", () => { try {
+            tar.kill();
+        }
+        catch { } });
+    }
     landingPage(res) {
         res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
         res.end(`<!doctype html><meta charset=utf-8><title>pantheon</title>
@@ -616,6 +724,19 @@ pantheon signup --email you@work.com --username you</code></pre>
             }
             catch { } }, 10);
         };
+        let helloTimer = setTimeout(() => {
+            if (!space) {
+                try {
+                    ws.close(1008, "HANDSHAKE_TIMEOUT");
+                }
+                catch { }
+            }
+        }, 20_000);
+        const clearHelloTimer = () => { if (helloTimer) {
+            clearTimeout(helloTimer);
+            helloTimer = null;
+        } };
+        ws.on("close", clearHelloTimer);
         this.send(ws, { t: "challenge", nonce, v: PROTOCOL_VERSION });
         ws.on("message", (raw) => {
             let msg;
@@ -644,19 +765,11 @@ pantheon signup --email you@work.com --username you</code></pre>
                 if (!verifyChallenge(m.pubkey, m.space, m.member, m.nonce, m.sig)) {
                     return reject("BAD_SIGNATURE", `signature does not match the presented key for "${m.member}"`);
                 }
-                let enrolled = null;
                 let sp;
                 if (m.enroll) {
                     sp = this.spaces.get(m.space) ?? null;
                     if (!sp)
                         return reject("NO_SUCH_SPACE", `no space "${m.space}" on this relay`);
-                    const r = sp.allow.redeem(m.enroll, m.member, m.pubkey);
-                    if (!r.ok) {
-                        this.log(`[${sp.name}] ! invite refused for ${m.member}: ${r.why}`);
-                        return reject("BAD_INVITE", r.fix ? `${r.why}\n${r.fix}` : r.why);
-                    }
-                    enrolled = sp.token;
-                    this.log(`[${sp.name}] * ENROLLED ${m.member} via invite from ${r.entry.admitted_by}${r.entry.may_wake ? " (may wake)" : ""}`);
                 }
                 else {
                     if (!this.spaces.has(m.space)) {
@@ -671,7 +784,7 @@ pantheon signup --email you@work.com --username you</code></pre>
                         this.noteSpaceCreate(ip);
                 }
                 let acctSession = null;
-                if (this.requireAccounts && this.accounts && !isTrustedSource(ip)) {
+                if (this.requireAccounts && this.accounts && !this.localTrusted(ip)) {
                     const auth = this.accounts.authorize(m.pubkey, m.member);
                     if (!auth.ok) {
                         const msg = auth.reason === "username_mismatch"
@@ -683,6 +796,16 @@ pantheon signup --email you@work.com --username you</code></pre>
                     m.member = auth.account.username;
                     acctSession = this.accounts.openSession(auth.account.id, auth.device.id, sp.name, ip).id;
                 }
+                let enrolled = null;
+                if (m.enroll) {
+                    const r = sp.allow.redeem(m.enroll, m.member, m.pubkey);
+                    if (!r.ok) {
+                        this.log(`[${sp.name}] ! invite refused for ${m.member}: ${r.why}`);
+                        return reject("BAD_INVITE", r.fix ? `${r.why}\n${r.fix}` : r.why);
+                    }
+                    enrolled = sp.token;
+                    this.log(`[${sp.name}] * ENROLLED ${m.member} via invite from ${r.entry.admitted_by}${r.entry.may_wake ? " (may wake)" : ""}`);
+                }
                 const verdict = enrolled ? "ok" : sp.allow.present(m.member, m.pubkey);
                 if (verdict === "key-mismatch") {
                     this.log(`[${sp.name}] ! REFUSED ${m.member}: key mismatch (${fingerprint(m.pubkey)})`);
@@ -701,6 +824,7 @@ pantheon signup --email you@work.com --username you</code></pre>
                     return;
                 }
                 space = sp;
+                clearHelloTimer();
                 sessionId = acctSession ?? this.mintSession();
                 role = m.role;
                 me = this.attach(sp, m.member, m.display ?? m.member, m.agent ?? "unknown", sessionId, m.role, ws, m.pkg);
@@ -1273,7 +1397,7 @@ pantheon signup --email you@work.com --username you</code></pre>
     }
     mayCreateSpace(ip) {
         const now = Date.now();
-        if (!isTrustedSource(ip)) {
+        if (!this.localTrusted(ip)) {
             const recent = (this.spaceCreates.get(ip) ?? []).filter((t) => now - t < 3_600_000);
             this.spaceCreates.set(ip, recent);
             if (recent.length >= this.limits.spaceCreatesPerHourPerIp) {
@@ -1291,7 +1415,7 @@ pantheon signup --email you@work.com --username you</code></pre>
         return null;
     }
     noteSpaceCreate(ip) {
-        if (isTrustedSource(ip))
+        if (this.localTrusted(ip))
             return;
         const arr = this.spaceCreates.get(ip) ?? [];
         arr.push(Date.now());
@@ -1360,12 +1484,18 @@ pantheon signup --email you@work.com --username you</code></pre>
         if (existing)
             return existing.token === token ? existing : null;
         const safe = name.replace(/[^a-z0-9._-]/gi, "_");
+        const allow = new Allowlist(this.dataDir, safe);
+        const match = allow.tokenMatches(token);
+        if (match === false)
+            return null;
+        if (match === null)
+            allow.bindToken(token);
         const store = new StateStore(this.dataDir, safe);
         const restored = store.load();
         const sp = {
             name, token,
             ledger: new Ledger(this.dataDir, safe),
-            allow: new Allowlist(this.dataDir, safe),
+            allow,
             store,
             members: new Map(),
             recent: new Map(),

package/dist/roster-file.js

@@ -1,9 +1,14 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "node:fs";
+import { createHash, timingSafeEqual } from "node:crypto";
 import { dirname, join } from "node:path";
 import { fingerprint } from "./identity.js";
+function hashToken(token) {
+    return createHash("sha256").update(token).digest("hex");
+}
 export class Allowlist {
     entries = new Map();
     invites = new Map();
+    tokenHash = null;
     file;
     constructor(dir, space) {
         this.file = join(dir, `${space}.members.json`);
@@ -14,14 +19,35 @@ export class Allowlist {
                 this.entries.set(e.member, e);
             for (const i of doc.invites ?? [])
                 this.invites.set(i.token, i);
+            this.tokenHash = doc.tokenHash ?? null;
         }
     }
     flush() {
         mkdirSync(dirname(this.file), { recursive: true });
-        writeFileSync(this.file, JSON.stringify({
+        const tmp = `${this.file}.tmp`;
+        writeFileSync(tmp, JSON.stringify({
             members: [...this.entries.values()],
             invites: [...this.invites.values()],
+            ...(this.tokenHash ? { tokenHash: this.tokenHash } : {}),
         }, null, 2) + "\n", { mode: 0o600 });
+        renameSync(tmp, this.file);
+    }
+    tokenMatches(token) {
+        if (!this.tokenHash)
+            return null;
+        const a = Buffer.from(hashToken(token), "hex");
+        const b = Buffer.from(this.tokenHash, "hex");
+        return a.length === b.length && timingSafeEqual(a, b);
+    }
+    bindToken(token) {
+        const h = hashToken(token);
+        if (this.tokenHash === h)
+            return;
+        this.tokenHash = h;
+        this.flush();
+    }
+    get hasToken() {
+        return this.tokenHash !== null;
     }
     mintInvite(by, mayWake, ttlMinutes, token) {
         const inv = {

package/dist/tray.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { CONFIG_DIR, load } from "./config.js";
 import { workerProc, notifierProc } from "./machine.js";
 import { agentHookStates } from "./notify.js";
+import { requireDeveloperTools } from "./notifier.js";
 import { plistPath, serviceInstalled, whichPantheon } from "./service.js";
 import { VERSION } from "./version.js";
 import { LIMITS } from "./protocol.js";
@@ -22,6 +23,7 @@ export function ensureTrayBinary(home = CONFIG_DIR) {
         throw new Error(`menu bar source is missing: ${source}`);
     const binary = trayBinaryPath(home);
     mkdirSync(dirname(binary), { recursive: true });
+    requireDeveloperTools("the menu bar", "menubar");
     execFileSync("/usr/bin/swiftc", ["-O", source, "-o", binary], { stdio: "pipe" });
     chmodSync(binary, 0o755);
     return binary;
@@ -75,7 +77,7 @@ export async function trayStatus(cfg = load()) {
     const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
     const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
     const [health, obligations] = await Promise.all([
-        getJson(`${base}/health`),
+        getJson(`${base}/health?space=${encodeURIComponent(cfg.space)}`),
         getJson(`${base}/obligations?${q}&member=${encodeURIComponent(`human:${cfg.member}`)}`),
     ]);
     const space = health

package/dist/update-check.js

@@ -2,27 +2,50 @@ import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
-import { repoRoot } from "./upgrade.js";
+import { repoRoot, PKG_NAME } from "./upgrade.js";
+import { VERSION } from "./version.js";
+export function semverGt(x, y) {
+    const p = (s) => s.split(".").map((n) => Number(n) || 0);
+    const [a, b] = [p(x), p(y)];
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    }
+    return false;
+}
 export function updateStatus(deps) {
     const cache = deps.readCache();
     if (cache && deps.now() - cache.checkedAt < deps.throttleMs) {
-        return { behind: cache.behind, refreshed: false };
+        return { behind: cache.behind, refreshed: false, latest: cache.latest };
+    }
+    if (deps.isGit()) {
+        try {
+            const behind = deps.fetchBehind();
+            deps.writeCache({ checkedAt: deps.now(), behind });
+            return { behind, refreshed: true };
+        }
+        catch {
+            return { behind: cache?.behind ?? 0, refreshed: false };
+        }
     }
-    if (!deps.isGit())
-        return { behind: cache?.behind ?? 0, refreshed: false };
     try {
-        const behind = deps.fetchBehind();
-        deps.writeCache({ checkedAt: deps.now(), behind });
-        return { behind, refreshed: true };
+        const latest = deps.npmLatest();
+        if (!latest)
+            return { behind: cache?.behind ?? 0, refreshed: false, latest: cache?.latest };
+        const behind = semverGt(latest, deps.current()) ? 1 : 0;
+        deps.writeCache({ checkedAt: deps.now(), behind, latest });
+        return { behind, refreshed: true, latest };
     }
     catch {
-        return { behind: cache?.behind ?? 0, refreshed: false };
+        return { behind: cache?.behind ?? 0, refreshed: false, latest: cache?.latest };
     }
 }
-export function versionLine(version, behind) {
-    return behind > 0
-        ? `pantheon ${version}  ·  ${behind} update${behind === 1 ? "" : "s"} behind — run \`pantheon upgrade\``
-        : `pantheon ${version}`;
+export function versionLine(version, behind, latest) {
+    if (behind <= 0)
+        return `pantheon ${version}`;
+    return latest
+        ? `pantheon ${version}  ·  ${latest} available — run \`pantheon upgrade\``
+        : `pantheon ${version}  ·  ${behind} update${behind === 1 ? "" : "s"} behind — run \`pantheon upgrade\``;
 }
 const cachePath = (home) => join(home ?? CONFIG_DIR, "update-check.json");
 export function defaultDeps(home) {
@@ -53,10 +76,19 @@ export function defaultDeps(home) {
             const out = execFileSync("git", ["-C", root, "rev-list", "--count", "HEAD..@{u}"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2500 }).trim();
             return Number(out) || 0;
         },
+        npmLatest: () => {
+            try {
+                return execFileSync("npm", ["view", PKG_NAME, "version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
+            }
+            catch {
+                return null;
+            }
+        },
+        current: () => VERSION,
     };
 }
 export function updateBanner(version, deps = defaultDeps()) {
-    const { behind } = updateStatus(deps);
-    return versionLine(version, behind);
+    const { behind, latest } = updateStatus(deps);
+    return versionLine(version, behind, latest);
 }
 //# sourceMappingURL=update-check.js.map

package/dist/upgrade.js

@@ -15,6 +15,7 @@ function pkgVersion(root) {
         return "unknown";
     }
 }
+export const PKG_NAME = "@join-pantheon/cli";
 export function defaultDeps() {
     const git = (root, ...args) => execFileSync("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
     return {
@@ -43,6 +44,15 @@ export function defaultDeps() {
             catch { }
             return up;
         },
+        npmUpgrade: () => execFileSync("npm", ["install", "-g", `${PKG_NAME}@latest`, "--no-audit", "--no-fund"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }),
+        npmLatest: () => {
+            try {
+                return execFileSync("npm", ["view", `${PKG_NAME}`, "version"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 4000 }).trim() || null;
+            }
+            catch {
+                return null;
+            }
+        },
     };
 }
 export function upgrade(deps = defaultDeps()) {
@@ -51,7 +61,25 @@ export function upgrade(deps = defaultDeps()) {
     const steps = [];
     const stop = (name, detail) => ({ root, from, to: from, steps: [...steps, { name, ok: false, detail }], ok: false, alreadyCurrent: false, restart: [] });
     if (!deps.isGit(root)) {
-        return stop("locate", `${root} is not a git checkout, so there is nothing to pull. This build was installed some other way — reinstall from the repo, or once pantheon is on npm, \`npm update -g @join-pantheon/cli\`.`);
+        try {
+            deps.npmUpgrade();
+            steps.push({ name: "npm", ok: true, detail: `installed ${PKG_NAME}@latest` });
+        }
+        catch (e) {
+            return stop("npm", `\`npm install -g ${PKG_NAME}@latest\` failed: ${e.message.split("\n")[0]}. ` +
+                `You may need to re-run it with the right permissions (or your Node version manager's global scope).`);
+        }
+        let wired = [];
+        try {
+            wired = deps.rewire();
+            steps.push({ name: "wire", ok: true, detail: wired.map((w) => `${w.tool}: ${w.status}`).join("  ") });
+        }
+        catch (e) {
+            steps.push({ name: "wire", ok: false, detail: `could not refresh agent config: ${e.message.split("\n")[0]} (run \`pantheon install --user\`)` });
+        }
+        const to = deps.npmLatest() ?? "latest";
+        const restart = [...deps.running(), "your agent session"];
+        return { root, from, to, steps, ok: true, alreadyCurrent: false, restart };
     }
     const dirty = deps.dirty(root);
     if (dirty.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.18.2",
+  "version": "0.19.1",
   "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": {
@@ -37,9 +37,9 @@
     "README.md",
     "LICENSE"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/guptasiddharth/agents-pantheon.git"
+  "homepage": "https://www.joinpantheon.network",
+  "bugs": {
+    "url": "https://www.joinpantheon.network/security"
   },
   "license": "MIT",
   "keywords": [