@join-pantheon/cli 0.29.1 → 0.31.0

package/dist/cli.js

@@ -7,11 +7,11 @@ process.emitWarning = ((warning, ...rest) => {
     return _emitWarning(warning, ...rest);
 });
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
 import { agentSpawn, CmdLineUnsafe } from "./which.js";
-import { fromInvite, looksLikeInviteCode, resolveInviteCode, load, save, toInvite, toJoinLink, resolveFor, loadAll, identity, 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, identity, repoInfo, bindRepo, bindFolder, unbindRepo, 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, installForUser } from "./install.js";
@@ -20,8 +20,8 @@ import { runMcp } from "./mcp.js";
 import { Worker } from "./worker.js";
 import { DEFAULT_REMINDER_MS, ensureNativeNotifier, HumanNotifier, sendDesktopNotification } from "./notifier.js";
 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, optOutsFrom } from "./setup-guide.js";
+import { AGENT_SURFACES, applyProfileInit, cleanList, isAgentSurface, loadProfile, organizationProfile, profileInitialized, saveProfile, wakeDefault, wakeMode } from "./profile.js";
+import { runGuide, terminalIO, questionOrNull, parseSetupFlags, questionnaire, optOutsFrom } from "./setup-guide.js";
 import { selectActs, formatAct, resolveRef } from "./history-view.js";
 import { doctor, render, shareBlock } from "./doctor.js";
 import { FEEDBACK_ADDRESS } from "./feedback.js";
@@ -35,16 +35,23 @@ import { createInterface } from "node:readline";
 import { homedir } from "node:os";
 import { removeHook, decideStop, writeIntent, clearIntent, readIntent, installHooks, agentHookStates } from "./notify.js";
 import { pending, render as renderPending } from "./pending.js";
-import { start as qsStart, join as qsJoin, wireUp, teamNameFor } from "./quickstart.js";
+import { signedRead } from "./reads.js";
+import { start as qsStart, join as qsJoin, wireUp, teamNameFor, deviceLabel } from "./quickstart.js";
 import { installService, uninstallService } from "./service.js";
-import { LIMITS } from "./protocol.js";
+import { ACTS, LIMITS } from "./protocol.js";
 import { loadPersonas, personaByName, describePersona, initPersona, personaDir } from "./persona.js";
 import { fingerprint, newKeypair, signAccount } from "./identity.js";
 import { VERSION } from "./version.js";
-import { connectFailure } from "./refusal.js";
+import { connectFailure, signInHint } from "./refusal.js";
 import * as mcpWindows from "./mcp-windows.js";
 import { updateBanner } from "./update-check.js";
+import { inWokenRun } from "./worker-policy.js";
 const argv = process.argv.slice(2);
+for (let i = argv.length - 1; i >= 1; i--) {
+    const m = /^(--[a-z][a-z0-9-]*)=(.*)$/i.exec(argv[i]);
+    if (m)
+        argv.splice(i, 1, m[1], m[2]);
+}
 const cmd = argv[0] ?? "help";
 function signedQuery(cfg, method, path, params, at = Date.now()) {
     const full = { ...params, pubkey: cfg.publicKey, ts: at };
@@ -72,6 +79,21 @@ function requireSignInOnHostedRelay(relayFlag) {
         return;
     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 pantheon start again.`);
 }
+async function requireSignInOnAccountsRelay(relayFlag) {
+    if (!relayFlag || identity()?.account)
+        return;
+    let hasAccounts = false;
+    try {
+        const base = relayFlag.replace(/^ws/, "http").replace(/\/+$/, "");
+        const res = await fetch(`${base}/auth/login`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}", signal: AbortSignal.timeout(6_000) });
+        hasAccounts = res.status !== 404;
+    }
+    catch {
+        return;
+    }
+    if (hasAccounts)
+        die(`sign in first — ${relayFlag} verifies email.${signInHint("NOT_SIGNED_IN", relayFlag)}\n  Then run this same pantheon start again.`);
+}
 async function interactiveOnboard(relayArg) {
     const prior = identity();
     const relay = relayArg ?? prior?.relay ?? process.env.PANTHEON_RELAY ?? DEFAULT_RELAY;
@@ -82,9 +104,16 @@ async function interactiveOnboard(relayArg) {
         return;
     }
     const rl = createInterface({ input: process.stdin, output: process.stderr });
-    const ask = (q) => new Promise((res) => rl.question(q, (a) => res(a.trim())));
+    const ask = async (q) => {
+        const a = await questionOrNull(rl, q);
+        if (a === null) {
+            console.error(D("\n  cancelled. Pick up where you left off: pantheon signup --email you@work.com --username you"));
+            process.exit(1);
+        }
+        return a;
+    };
     const kp = prior?.publicKey && prior.privateKey ? { publicKey: prior.publicKey, privateKey: prior.privateKey } : newKeypair();
-    const label = `${process.env.USER ?? "a"}'s ${process.platform === "darwin" ? "mac" : process.platform}`;
+    const label = deviceLabel();
     const postJson = async (path, body) => fetch(`${base}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })
         .then(async (x) => ({ status: x.status, j: await x.json() }));
     try {
@@ -166,7 +195,8 @@ async function interactiveOnboard(relayArg) {
                 console.error(`         ${C("pantheon join <invite-link>")}  ${D("(join a teammate's team)")}`);
                 return;
             }
-            console.error(D(`    ${v.j.error ?? "that code is not right"} — try again${v.j.reason === "expired" ? ", or type 'resend'" : ""}`));
+            const spent = v.j.reason === "expired" || v.j.reason === "too_many_attempts" || v.j.tries_left === 0;
+            console.error(D(`    ${v.j.error ?? "that code is not right"}${spent ? " — type 'resend' for a new code" : " — try again"}`));
         }
         console.error(D("\n  Too many tries. Run `pantheon` again to restart, or `pantheon verify <code>` once you have it."));
     }
@@ -228,10 +258,199 @@ function sameHost(a, b) {
         return false;
     }
 }
+async function findAndBindRepos(all, m, teamRepos, opts = {}) {
+    const want = teamRepos.map((r) => r.fingerprint);
+    if (!want.length) {
+        console.error(D(`  "${m.name}" has no repos registered yet — the first member to connect from a clone registers it`));
+        return;
+    }
+    const name = (fp) => { const r = teamRepos.find((x) => x.fingerprint === fp); return r?.origin ? r.origin.replace(/^.*[:/]([^:/]+)$/, "$1") : fp; };
+    const already = new Set(Object.entries(all.bindings ?? {}).filter(([, b]) => b.space === m.id).map(([k]) => k));
+    const unbound = new Set(all.unbound ?? []);
+    for (const fp of want.filter((f) => unbound.has(f) && !already.has(f)))
+        console.error(D(`  ${name(fp)}: you unbound it on this machine — left so (pantheon use ${m.name} --here inside it to bind it again)`));
+    const todo = want.filter((fp) => !already.has(fp) && !unbound.has(fp));
+    if (!todo.length) {
+        console.error(`${C("✓")} every repo "${m.name}" works from is bound on this machine: ${want.map(name).join(", ")}`);
+        return;
+    }
+    let recents = opts.recents;
+    const tty = !!process.stdin.isTTY && !!process.stderr.isTTY;
+    if (recents === undefined && tty) {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        const a = ((await questionOrNull(rl, `Also look in the folders your editors and agents have opened? Only their paths are read, and nothing leaves this machine. [Y/n] `)) ?? "").trim().toLowerCase();
+        rl.close();
+        recents = a === "" || a.startsWith("y");
+    }
+    const { findTeamClones } = await import("./repo-find.js");
+    console.error(D(`  looking for ${todo.map(name).join(", ")} on this machine…`));
+    let found = findTeamClones(todo, { recents: !!recents, ...(opts.extra ? { extra: opts.extra } : {}) });
+    let missing = todo.filter((fp) => !found.some((f) => f.repo.fingerprint === fp));
+    if (missing.length && tty) {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        const a = ((await questionOrNull(rl, `  Not found: ${missing.map(name).join(", ")}. The folder your repos live in (Enter to skip): `)) ?? "").trim();
+        rl.close();
+        if (a) {
+            const more = findTeamClones(missing, { extra: [resolve(a.replace(/^~(?=$|\/)/, homedir()))] });
+            found = [...found, ...more];
+            missing = missing.filter((fp) => !more.some((f) => f.repo.fingerprint === fp));
+        }
+    }
+    const elsewhere = found.filter((f) => { const b = all.bindings?.[f.repo.fingerprint]; return !!b && b.space !== m.id; });
+    for (const f of elsewhere)
+        console.error(`  ${D("–")} ${name(f.repo.fingerprint).padEnd(18)} ${f.repo.root}   ${D(`bound to "${findMembership(all, all.bindings[f.repo.fingerprint].space)?.name ?? all.bindings[f.repo.fingerprint].space}" — left there (pantheon use ${m.name} --here inside it to move it)`)}`);
+    found = found.filter((f) => !elsewhere.includes(f));
+    for (const f of found)
+        console.error(`  ${C("✓")} ${name(f.repo.fingerprint).padEnd(18)} ${f.repo.root}   ${D(`(${f.how})`)}`);
+    for (const fp of missing)
+        console.error(`  ${D("✗")} ${name(fp).padEnd(18)} ${D("not on this machine — clone it, then: pantheon repo find")}`);
+    if (!found.length)
+        return;
+    let go = !!opts.yes || !!opts.auto;
+    if (!go && tty) {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        const a = ((await questionOrNull(rl, `Use ${found.length === 1 ? "it" : `these ${found.length}`} for "${m.name}"? [Y/n] `)) ?? "").trim().toLowerCase();
+        rl.close();
+        go = a === "" || a.startsWith("y");
+    }
+    if (!go) {
+        console.error(D(`  nothing bound${tty ? "" : " — run it again with --yes to bind them"}`));
+        return;
+    }
+    for (const f of found)
+        bindRepo(f.repo, m.id);
+    const them = found.length === 1 ? "it" : "them";
+    console.error(`${B("bound")} ${found.map((f) => name(f.repo.fingerprint)).join(", ")} → "${m.name}" — agents opened in ${them} speak for the team, and your worker (when it is on) serves ${them}`);
+}
+async function bindReposIn(dir, all, m, yes, again) {
+    const found = (await import("./repo-find.js")).reposUnder(dir, 3);
+    const taken = found.filter((r) => { const b = all.bindings?.[r.fingerprint]; return !!b && b.space !== m.id; });
+    for (const r of taken)
+        console.error(D(`  ${repoLabel(r)} is bound to "${findMembership(all, all.bindings[r.fingerprint].space)?.name ?? all.bindings[r.fingerprint].space}" — left there (pantheon use ${m.name} --here inside it to move it)`));
+    const unbound = new Set(all.unbound ?? []);
+    for (const r of found.filter((x) => unbound.has(x.fingerprint)))
+        console.error(D(`  ${repoLabel(r)}: you unbound it on this machine — left so (pantheon use ${m.name} --here inside it to bind it again)`));
+    let inside = found.filter((r) => !taken.includes(r) && !unbound.has(r.fingerprint));
+    if (inside.length && !yes) {
+        console.error(`  ${B("repos in it")}  ${inside.map(repoLabel).join(", ")}`);
+        if (process.stdin.isTTY) {
+            const rl = createInterface({ input: process.stdin, output: process.stderr });
+            const a = ((await questionOrNull(rl, `  Bind ${inside.length === 1 ? "it" : `these ${inside.length}`} to "${m.name}" and register ${inside.length === 1 ? "it" : "them"} with the team? [Y/n] `)) ?? "").trim().toLowerCase();
+            rl.close();
+            if (!(a === "" || a.startsWith("y")))
+                inside = [];
+        }
+        else {
+            console.error(D(`  not bound yet — to bind and register them with "${m.name}": ${again}`));
+            inside = [];
+        }
+    }
+    if (!inside.length)
+        return 0;
+    for (const r of inside)
+        bindRepo(r, m.id);
+    const c = configFor(loadAll() ?? all, m, null);
+    const client = new PantheonClient(c, undefined, { role: "cli" });
+    const registered = [], failed = [];
+    try {
+        await client.connect();
+        for (const r of inside) {
+            if (client.repos.some((x) => x.fingerprint === r.fingerprint)) {
+                registered.push(repoLabel(r));
+                continue;
+            }
+            await client.bindRepo(r.fingerprint, repoShare(r)).then(() => registered.push(repoLabel(r)), (e) => failed.push(`${repoLabel(r)} (${e.message.split("\n")[0]})`));
+        }
+    }
+    catch (e) {
+        failed.push(...inside.map((r) => `${repoLabel(r)} (${e.message.split("\n")[0]})`));
+    }
+    finally {
+        client.close();
+    }
+    console.error(`  ${B("repos in it")}  ${inside.map(repoLabel).join(", ")} — each bound to "${m.name}"${registered.length ? "" : D(" here")}`);
+    if (failed.length)
+        console.error(D(`  not registered with the team yet: ${failed.join("; ")} — pantheon repo add, from each, when the relay is reachable`));
+    return inside.length;
+}
+async function bindReposHere(yes) {
+    const cwd = process.cwd();
+    if (repoInfo(cwd))
+        return;
+    const real = (d) => { try {
+        return realpathSync.native(d);
+    }
+    catch {
+        return resolve(d);
+    } };
+    const here = real(cwd);
+    if (here === real(homedir()) || dirname(here) === here)
+        return;
+    if (["Downloads", "Desktop", "Documents", "Library"].some((n) => here === join(real(homedir()), n)))
+        return;
+    const all = loadAll(), j = load();
+    const m = all && j ? findMembership(all, j.spaceId ?? j.space) ?? findMembership(all, j.space) : null;
+    if (!all || !m)
+        return;
+    const n = (await import("./repo-find.js")).reposUnder(cwd, 3).length;
+    if (!n)
+        return;
+    console.error("");
+    const many = n > 6 && !process.stdin.isTTY;
+    if (many) {
+        console.error(D(`  this folder holds ${n} repos — to bind and register them all with "${m.name}": pantheon use ${m.name} --here --yes   (or pantheon repo find, which binds only the team's own)`));
+        return;
+    }
+    await bindReposIn(cwd, all, m, yes, `pantheon use ${m.name} --here --yes`).catch((e) => console.error(D(`  could not bind the repos here: ${e.message}`)));
+}
+async function workerAfterBinding(how) {
+    if (how === "off")
+        return;
+    const j = load();
+    if (!j?.spaceId || wakeMode(loadProfile(j)) === "no")
+        return;
+    const { serviceInstalled, servicesUnavailable } = await import("./service.js");
+    if (servicesUnavailable(process.platform) || serviceInstalled("worker"))
+        return;
+    const ws = (await import("./worker-fleet.js")).teamWorkspaces(loadAll(), j.spaceId);
+    if (!ws.length)
+        return;
+    try {
+        const { commandsChosen } = await import("./profile.js");
+        const commandsOn = ws.some((w) => w.kind === "repo") && commandsChosen() !== false;
+        installService("worker", ws[0].path, commandsOn ? ["--allow-bash"] : []);
+        console.error(`  ${C("✓")} worker on — serves ${ws.map((w) => w.name).join(", ")} while you are away${wakeMode(loadProfile(j)) === "approved" ? "; you are asked the first time each teammate needs it" : ""}${commandsOn ? "; a run may run tests, commit and push to its own branch (edits only: pantheon setup --commands no)" : ""}`);
+    }
+    catch (e) {
+        console.error(D(`  the worker did not install: ${e.message} — pantheon service install worker`));
+    }
+}
+const repoLabel = (r) => r.origin ?? basename(r.root);
+const repoShare = (r) => (r.origin ? r.origin.replace(/^.*[:/]([^:/]+)$/, "$1") : basename(r.root));
+const teamFlag = (cfg) => (flag("space") ? ` --space ${cfg.space}` : "");
 function need() {
     const r = resolveFor(process.cwd());
-    if (r.cfg && r.cfg.space)
+    if (flag("space") && !["start", "profile"].includes(cmd)) {
+        const f = loadAll();
+        const m = f && findMembership(f, flag("space"));
+        if (!f || !m)
+            die(`you are not in a team called "${flag("space")}". Yours: ${Object.values(f?.spaces ?? {}).map((x) => x.name).join(", ") || "none"}`);
+        return r.cfg && (r.cfg.spaceId === m.id || r.cfg.space === m.name) && r.reason !== "default" ? r.cfg : configFor(f, m, null);
+    }
+    if (r.cfg && r.cfg.space) {
+        if (r.autoBound && r.repo && r.cfg.spaceId) {
+            try {
+                bindRepo(r.repo, r.cfg.spaceId);
+                console.error(D(`  ${r.repo.origin ?? r.repo.root} is one of "${r.cfg.space}"'s repos — bound here`));
+            }
+            catch { }
+        }
         return r.cfg;
+    }
+    if (r.claimedBy?.length)
+        die(`this repo is listed by more than one of your teams (${r.claimedBy.join(", ")}) — pick one: pantheon use <team> --here   (or name it: --space <team>)`);
+    if (r.repoUnknown)
+        die(`git did not answer in this folder, so which team this repo is bound to cannot be told — and a command for the wrong team is worse than none.\n  Check that git works here (git status), then run it again — or name the team: --space <team>`);
     if (r.reason === "unbound") {
         const names = Object.values(loadAll()?.spaces ?? {}).map((m) => m.name).join(", ");
         die(`this folder is not bound to one of your ${r.memberships} teams (${names}).\n  From the team's repo:  pantheon use <team> --here\n  Or pick a default:      pantheon use <team>`);
@@ -239,7 +458,7 @@ function need() {
     if (r.reason === "stale")
         die(`this repo is bound to a team this machine is no longer in (${r.binding?.space}).\n  Rebind it:  pantheon use <team> --here   ·   or rejoin:  pantheon join <invite>`);
     if (r.cfg && !r.cfg.space)
-        die("signed in, but not on a team yet. Run `pantheon start` (create one) or `pantheon join <invite>` (join one).");
+        die(`${r.cfg.account ? "signed in" : "this machine has a key"}, but is not on a team yet. Run \`pantheon start\` (create one) or \`pantheon join <invite>\` (join one).`);
     return die("not configured. Run `pantheon signup` then `pantheon start` (create a team), or `pantheon join <invite>` (join one).");
 }
 function targets() {
@@ -303,6 +522,17 @@ function printGranted(granted) {
         console.error(`  \u2022 ${g}`);
     console.error(D(`  Undo: pantheon hook uninstall  ·  pantheon service uninstall worker`));
 }
+function printRelayNote(relay) {
+    let host = relay ?? "the relay";
+    try {
+        if (relay)
+            host = new URL(relay.replace(/^ws/, "http")).host;
+    }
+    catch { }
+    console.error(D(`\n  Your team's messages go through ${host}. Whoever runs it can read them (they are not end-to-end encrypted), so treat the team like a shared channel;`));
+    console.error(D(`  on a relay from 0.31 on, it cannot write or change one in a teammate's name without your machine noticing: every message is signed by its sender. Your own relay: pantheon relay`));
+}
+const HUD_ACTION_MAX_AGE_MS = 30_000;
 function unattendedProject() {
     if (argv.includes("--no-worker"))
         return { project: null, how: "off" };
@@ -321,7 +551,23 @@ async function guidedSetup(cfg, project, opts = {}) {
     const io = rl ? terminalIO(rl, (l) => console.error(l)) : null;
     console.error(`\n${B("A few choices, then you're done.")}${io ? "" : Object.keys(preset).length ? D("  (applying the answers you passed)") : D("  (no terminal — taking the defaults)")}`);
     try {
-        const r = await runGuide(io, { cfg, project, optOut: optOutsFrom(argv) }, {
+        let serves = null;
+        if (!project && cfg.spaceId) {
+            try {
+                const ws = (await import("./worker-fleet.js")).teamWorkspaces(loadAll(), cfg.spaceId);
+                if (ws.length)
+                    serves = { path: ws[0].path, repos: ws.some((w) => w.kind === "repo") };
+            }
+            catch { }
+        }
+        const { agentsNeedingUnsandboxed } = await import("./agents.js");
+        const r = await runGuide(io, { cfg, project, optOut: optOutsFrom(argv), serves, ...(opts.founder !== undefined ? { founder: opts.founder } : {}) }, {
+            unsandboxedAgents: () => { try {
+                return agentsNeedingUnsandboxed();
+            }
+            catch {
+                return [];
+            } },
             publish: async (p) => {
                 const c = new PantheonClient(cfg, undefined, { role: "cli" });
                 try {
@@ -377,21 +623,33 @@ async function workdirFor(cfg, hud) {
     return pickWorkdir(bindings, hints, team);
 }
 async function fetchHistory(cfg, opts = {}) {
-    const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
-    const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`
-        + (opts.goal ? `&goal=${encodeURIComponent(opts.goal)}` : opts.since !== undefined ? `&since=${opts.since}` : "");
-    const res = await fetch(`${base}/history?${q}`, { signal: AbortSignal.timeout(8000) });
+    const res = await signedRead(cfg, "/history", opts.goal ? { goal: opts.goal } : opts.since !== undefined ? { since: opts.since } : {}, { timeoutMs: 8000 });
     if (!res.ok)
-        throw new Error(`relay answered ${res.status} for the ledger`);
+        throw await readFailure(cfg, res, "the ledger");
     return (await res.json()).acts ?? [];
 }
+async function readFailure(cfg, res, what) {
+    const why = await res.json().then((j) => j.error).catch(() => undefined);
+    if (res.status === 401 || res.status === 403) {
+        const c = new PantheonClient(cfg, undefined, { role: "cli" });
+        try {
+            await c.connect();
+        }
+        catch (e) {
+            return new Error(c.pending ?? connectFailure(e, cfg.relay));
+        }
+        finally {
+            c.close();
+        }
+    }
+    return new Error(`relay answered ${res.status} for ${what}${why ? `: ${why}` : ""}`);
+}
 async function fetchAct(cfg, id, budgetMs = Number.POSITIVE_INFINITY) {
     const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
-    const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
     const deadline = Date.now() + budgetMs;
     const left = () => Math.max(1, Math.min(8000, deadline - Date.now()));
     try {
-        const res = await fetch(`${base}/act?${q}&id=${encodeURIComponent(id)}`, { signal: AbortSignal.timeout(left()) });
+        const res = await signedRead(cfg, "/act", { id }, { timeoutMs: left() });
         if (res.ok) {
             const body = await res.json();
             if (body.act)
@@ -469,11 +727,36 @@ function reportWindows(installed) {
     if (ended.length)
         console.error(D(`  ended ${ended.length} pantheon server${ended.length > 1 ? "s" : ""} left behind by windows that no longer exist`));
 }
+const AGENT_ROWS = new Set(["claude code", "cursor", "codex", "copilot", "vs code", "kiro"]);
+const rowFailed = (status) => /^(failed|could not)/i.test(status);
+function readiness(tools) {
+    const agents = tools.filter((t) => AGENT_ROWS.has(t.tool));
+    const attempted = agents.filter((t) => !/^skipped/i.test(t.status));
+    return { failed: tools.filter((t) => rowFailed(t.status)), wired: attempted.filter((t) => !rowFailed(t.status)).length, attempted: attempted.length };
+}
 function printReady(tools) {
     const workerOn = tools.some((t) => t.tool === "worker" && t.status.startsWith("on"));
-    console.error(`\n${B("You're set.")} Restart your agent once (quit and reopen) and it is connected.`);
+    const r = readiness(tools);
+    if (r.failed.length) {
+        console.error(`\n\x1b[31m${B("Not everything was set up:")}\x1b[0m`);
+        for (const f of r.failed)
+            console.error(`  ${f.tool.padEnd(14)}${f.status}`);
+    }
+    if (r.attempted && !r.wired) {
+        console.error(`\n\x1b[31m  No agent on this machine is connected to pantheon.\x1b[0m ${D("Fix the lines above, then run: pantheon install --user")}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!r.attempted) {
+        console.error(`\n${B("No agent CLI was found on this machine,")} so nothing is connected yet. ${D("Install Claude Code, Codex, Cursor, Copilot or Kiro, then run: pantheon install --user")}`);
+        return;
+    }
+    if (r.failed.length)
+        console.error(`\n${B("Partly set.")} ${D("The agents that did not fail above connect once you restart them; fix the rest, then: pantheon install --user")}`);
+    else
+        console.error(`\n${B("You're set.")} Restart your agent once (quit and reopen) and it is connected.`);
     if (workerOn)
-        console.error(D(`  While you're away, a teammate you grant may-wake can hand work to this machine —`));
+        console.error(D(`  While you're away, a teammate you approve to wake this machine can hand work to it —`));
     if (workerOn)
         console.error(D(`  isolated branch, no secrets in the worktree. Pause any time from the menu bar.`));
     const oneTime = new Map();
@@ -497,9 +780,17 @@ function printReady(tools) {
             console.error(D(`  ${l}`));
     }
 }
-const B = (s) => `\x1b[1m${s}\x1b[0m`;
-const D = (s) => `\x1b[2m${s}\x1b[0m`;
-const C = (s) => `\x1b[36m${s}\x1b[0m`;
+const PLAIN = !!process.env["NO_COLOR"];
+if (PLAIN) {
+    const SGR = /\x1b\[[0-9;]*m/g;
+    for (const stream of [process.stdout, process.stderr]) {
+        const write = stream.write.bind(stream);
+        stream.write = ((chunk, ...rest) => write(typeof chunk === "string" ? chunk.replace(SGR, "") : chunk, ...rest));
+    }
+}
+const B = (s) => PLAIN ? s : `\x1b[1m${s}\x1b[0m`;
+const D = (s) => PLAIN ? s : `\x1b[2m${s}\x1b[0m`;
+const C = (s) => PLAIN ? s : `\x1b[36m${s}\x1b[0m`;
 const HELP = `${B("pantheon")} — your agent and your teammates' agents, working together
 
 ${B("first time — verify your email once")}
@@ -521,14 +812,14 @@ ${B("getting going — two commands, from your project's repo if you have one")}
 
   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
-  explicit may-wake grant to use it), native decision alerts, menu bar. Opt-outs:
+  team while you are away — on when run from a git repo; a peer still needs you
+  to approve them here to use it: pantheon wake allow), native decision alerts, menu bar. Opt-outs:
   --no-worker, --no-hook, --no-notifications, --no-menubar.
   Already a member, new machine or fresh pull?  pantheon install --user  does the same.
 
 ${B("several teams on one machine")}
   pantheon spaces             your teams, which repo is bound to which, and where this folder points
-  pantheon use <team> --here  bind this repo to a team (agents opened here speak in it)
+  pantheon use <team> --here  bind this repo or folder to a team (agents opened here speak in it); --unbind undoes it
   pantheon repo add | list    the repos a team works from; a delivery must come from one of them
                               (repo add --base <branch>: the branch workers cut from, else origin's default)
   pantheon leave <team>       drop one team from this machine (its token and repo bindings)
@@ -544,7 +835,10 @@ ${B("day to day")}
   pantheon logs [-f]          the relay's log
 
 ${B("control")}
-  pantheon admit <who>        let someone in       (--may-wake to allow unattended work here)
+  pantheon admit <who>        let someone in       (--may-wake: the team lets them wake workers, and this machine allows them)
+  pantheon wake allow <who>   let a teammate wake THIS machine; wake deny <who> takes it back; wake list shows who can
+  pantheon trust [<who>]      the teammates' keys this machine checks their messages against; trust <who> adopts a changed one
+                              (this machine only — nothing is sent to the team; --space <team> to pick one)
   pantheon admit <who> --revoke     remove them
   pantheon worker             stay answerable while you are away
                             (--agent claude-code|codex|cursor|copilot|kiro|auto, --persona <name>)
@@ -563,7 +857,7 @@ ${B("control")}
                             (auto-detects claude / codex / cursor / copilot / kiro on this machine)
   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 panic              emergency stop: ends the run in flight and the worker, and switches off wake rights in every team you are in
   pantheon doctor [--share]   check this machine end to end; --share prints it without names or paths, to paste to us
   pantheon network [--proxy <url> | --direct | --clear]   how this machine reaches the relay; save a proxy for every Pantheon process here
   pantheon setup              three questions — your name, your role, may a woken run execute commands —
@@ -575,14 +869,14 @@ ${B("control")}
 
 ${D("more: pantheon help --all")}
 `;
-const HELP_ALL = HELP + `
+const HELP_ALL = HELP.replace(/\n[^\n]*more: pantheon help --all[^\n]*\n?$/, "\n") + `
 ${B("less common")}
   pantheon relay              run only the relay, in this terminal
   pantheon service install [relay|worker|notifier|menubar] | restart | uninstall
                             run a long-lived component in the background, from login
   pantheon members            the full list, with key fingerprints
-  pantheon whoami             your name and fingerprint
   pantheon pending            what a live agent window has not yet seen
+  pantheon goal open "<title>" --with <who>   open a goal to work in   (goal list · goal close <id> "<summary>")
   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)
@@ -607,6 +901,31 @@ function usageFor(command, help) {
     }
     return out.length ? out.join("\n") : null;
 }
+const COMMAND_FLAGS = {
+    start: "--space <name>  --relay <url>  --me <name>  --port <n>  --ttl <minutes>  --no-worker  --no-hook  --no-notifications  --no-menubar  --reset  --yes\n  and every setup answer as a flag (--name, --title, --wake, --commands, --alerts, --decides …): pantheon setup --questions",
+    join: "<invite link | line | code>  --relay <url>  --me <name>  --no-worker  --no-hook  --no-notifications  --no-menubar  --reset  --yes\n  and every setup answer as a flag: pantheon setup --questions",
+    invite: "--list  --revoke <token|all>  --may-wake | --no-wake  --ttl <minutes>",
+    admit: "<member>  --may-wake | --no-wake  --revoke  --forget  --yes",
+    wake: "allow <member> | deny <member> | list   --space <team>",
+    trust: "[<member>]  --yes  --space <team>",
+    say: "<ACT> <text>  --to <member>[,<member>]  --goal <id>  --ref <id | seq | last>  --summary '<one line>'  --domains <a,b>  --branch --commit --remote (DELIVERED)  --space <team>",
+    goal: "list | open \"<title>\" --with <member>[,…] [--acceptance \"…\"] [--deadline <ISO time>] [--list] | close <id> \"<summary>\"",
+    history: "--goal <id>  --from <member>  --last <n>  --since <seq>  --short  --presence  --json",
+    network: "--proxy <url> [--no-proxy <hosts>]  |  --direct  |  --clear",
+    leave: "[<team>]  --yes  --keep-identity  --stop-relay  --project <dir>",
+    stop: "[relay|worker|notifier|menubar|all]  --port <n>",
+    logs: "[relay|worker|notifier|menubar]  --follow  --n <lines>",
+    worker: "--agent <claude-code|codex|cursor|copilot|kiro|auto>  --persona <name>  --project <dir>  --allow-bash  --max-runs <n>  --max-runs-day <n>  --grace <s>  --once",
+    service: "install [relay|worker|notifier|menubar] | restart <kind> | uninstall <kind>   --project <dir>  --allow-bash",
+    doctor: "--share  --project <dir>",
+    relay: "--port <n>  --host <address>  --data <dir>",
+    use: "<team>  --here  --yes   ·   pantheon use --unbind   (this folder or repo bound to no team again)",
+    repo: "add [--base <branch>] | list [--all] | find [<folder>] [--recents] [--yes]",
+    login: "--email <address>  --relay <url>  --label <device name>",
+    signup: "--email <address>  --username <name>  --relay <url>  --label <device name>",
+    audit: "--space <team>  --since <hours>  --json",
+    setup: "--questions  (and every answer as a flag, with --yes)",
+};
 const HELP_OPAQUE = new Set(["mcp", "hook", "pending", "tray-status", "help", "version", "-v", "--help", "-h"]);
 function rememberWorkingProxy() {
     try {
@@ -622,7 +941,54 @@ function rememberWorkingProxy() {
     }
     catch { }
 }
+async function teamStanding(all, m) {
+    const c = new PantheonClient(configFor(all, m, null), undefined, { role: "cli" });
+    try {
+        await Promise.race([c.connect(), new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 8_000))]);
+        return { others: c.members.filter((x) => x.admitted && x.member !== all.member).map((x) => x.member), founder: !!c.members.find((x) => x.member === all.member)?.founder };
+    }
+    catch {
+        return { others: null, founder: false };
+    }
+    finally {
+        c.close();
+    }
+}
+function slipDistance(a, b) {
+    const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+    for (let j = 1; j <= b.length; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= a.length; i++)
+        for (let j = 1; j <= b.length; j++) {
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+        }
+    return d[a.length][b.length];
+}
+const EXTRA_FLAGS = "--agent-cmd --approve-all --ask-before-sending --child --code --data --device --display --force --help --host --idle --keywords --local " +
+    "--no-continue --no-guide --no-notify --path --peek --poll --portable --publish --queued --quiet --remind --scratch --session --surface --token --unattended " +
+    "--until --user --version --all --json " +
+    "--name --title --wake --commands --unsandboxed --alerts --decides --playbook --base --responsibilities --human-required --agent-can-decide --capabilities";
+const KNOWN_FLAGS = new Set([...`${Object.values(COMMAND_FLAGS).join(" ")} ${EXTRA_FLAGS}`.matchAll(/--([a-z][a-z0-9-]*)/g)].map((m) => m[1]));
+function refuseUnknownFlags() {
+    if (["mcp", "hook", "tray-status", "_menubar"].includes(cmd))
+        return;
+    for (const a of argv.slice(1)) {
+        if (!/^--[a-z][a-z0-9-]*(?:=\S*)?$/i.test(a))
+            continue;
+        const name = a.slice(2).split("=")[0].toLowerCase();
+        if (KNOWN_FLAGS.has(name))
+            continue;
+        const own = [...(COMMAND_FLAGS[cmd] ?? "").matchAll(/--([a-z][a-z0-9-]*)/g)].map((m) => m[1]);
+        const rank = (ks) => ks.map((k) => ({ k, d: slipDistance(name, k) })).sort((x, y) => x.d - y.d)[0];
+        const mine = rank(own);
+        const near = mine && mine.d <= 2 ? mine : rank([...KNOWN_FLAGS]);
+        die(`unknown flag ${a}${near && near.d <= 2 ? ` — did you mean --${near.k}?` : ""}\n  Nothing was run. pantheon ${cmd} --help shows its usage${cmd === "say" ? "; if it is part of your message, put the message in quotes" : ""}.`);
+    }
+}
 async function main() {
+    refuseUnknownFlags();
     try {
         await installNetwork();
     }
@@ -641,11 +1007,15 @@ async function main() {
         }
         return interactiveOnboard();
     }
-    if (!HELP_OPAQUE.has(cmd)) {
+    const askedHelpOnly = argv.length === 2 && (argv[1] === "--help" || argv[1] === "-h") && ["pending", "hook"].includes(cmd);
+    if (!HELP_OPAQUE.has(cmd) || askedHelpOnly) {
         const helpAt = cmd === "say" ? [argv[1]] : argv.slice(1);
         if (helpAt.some((a) => a === "--help" || a === "-h")) {
             const u = usageFor(cmd, HELP_ALL);
-            console.error(u ? `${u}\n\n${D("nothing was run · all commands: pantheon help --all")}` : HELP);
+            const flags = COMMAND_FLAGS[cmd];
+            const teamCmd = !["start", "join", "signup", "login", "verify", "whoami", "relay", "help", "version", "upgrade", "network", "ps", "stop", "service", "hook", "mcp", "pending", "tray-status"].includes(cmd);
+            const shown = flags && teamCmd && !/--space/.test(flags) ? `${flags}\n  --space <team>   (the team to act on, when this folder is bound to another or none)` : flags;
+            console.log(u || shown ? `${u ?? `  pantheon ${cmd}`}${shown ? `\n\n${B("flags")}\n  ${shown}` : ""}\n\n${D("nothing was run · all commands: pantheon help --all")}` : HELP);
             return;
         }
     }
@@ -656,7 +1026,28 @@ async function main() {
             if (set !== undefined) {
                 const p = normalizeProxy(set) ?? die(`"${redactText(set)}" is not a proxy address — use http://host:port (add user:password@ if it needs a login)`);
                 saveAll({ ...all, network: { proxy: p, ...(flag("no-proxy") ? { no_proxy: flag("no-proxy") } : {}), source: "pantheon network", saved_at: Date.now() } });
-                console.error(`${B("saved")} every Pantheon process on this machine now reaches the relay through ${redactProxy(p)}`);
+                const knock = await (async () => {
+                    try {
+                        const u = new URL(p);
+                        const { connect } = await import("node:net");
+                        const port = Number(u.port) || (u.protocol === "https:" ? 443 : 80);
+                        return await new Promise((done) => {
+                            const sock = connect({ host: u.hostname, port, timeout: 3_000 });
+                            sock.once("connect", () => { sock.destroy(); done(null); });
+                            sock.once("timeout", () => { sock.destroy(); done("did not answer in 3s"); });
+                            sock.once("error", (e) => done(e.code === "ENOTFOUND" ? "its name did not resolve" : e.code === "ECONNREFUSED" ? "nothing is listening there" : e.message));
+                        });
+                    }
+                    catch (e) {
+                        return e.message;
+                    }
+                })();
+                if (knock) {
+                    console.error(`${B("saved")} ${redactProxy(p)} — but right now ${knock}. Every Pantheon process here will try it; check the address, or undo: pantheon network --clear`);
+                }
+                else {
+                    console.error(`${B("saved")} every Pantheon process on this machine will go through ${redactProxy(p)} (it answered). pantheon doctor checks the relay through it.`);
+                }
                 return;
             }
             if (argv.includes("--direct")) {
@@ -686,13 +1077,14 @@ async function main() {
                 die(setupFlags.errors.join("\n") + "\n  pantheon setup --questions  lists every answer");
             const wp = unattendedProject();
             requireSignInOnHostedRelay(flag("relay"));
+            await requireSignInOnAccountsRelay(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: "${teamNameFor(process.cwd())}". Pass --space <name> to choose.\n`));
             const r = await qsStart({
                 port,
                 dataDir: resolveDataDir(flag("data")).dir,
-                ttlMinutes: Number(flag("ttl", "1440")),
+                ttlMinutes: numFlag("ttl", 1440),
                 reset: argv.includes("--reset"),
                 ...(flag("space") ? { space: flag("space") } : {}),
                 ...(flag("me") ? { me: flag("me") } : {}),
@@ -708,8 +1100,9 @@ async function main() {
             for (const t of r.tools)
                 console.error(`  ${t.tool.padEnd(14)}${t.status}`);
             for (const w of r.warnings)
-                console.error(`\x1b[33m  ! ${w}\x1b[0m`);
+                console.error(`\x1b[33m  ! ${w}\x1b[0m` + (/NOT_SIGNED_IN/.test(w) ? signInHint("NOT_SIGNED_IN", r.cfg.relay) : ""));
             printGranted(r.granted);
+            printRelayNote(r.cfg?.relay);
             rememberWorkingProxy();
             if (!r.claimed) {
                 console.error(`\n\x1b[31m  No team was created.\x1b[0m ${D("Fix the warning above, then run `pantheon start` again.")}`);
@@ -729,18 +1122,25 @@ async function main() {
                     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(`  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(`  From the folder they work in — a clone of the team's repo, or any folder for docs and plans (no git needed). Single use, expires in ${Math.round(numFlag("ttl", 1440) / 60)}h.`));
                 console.error(D(`  Redeeming it admits them — no separate approval step. Need another? \`pantheon invite\``));
+                console.error(r.inviteMayWake
+                    ? `  ${B("It also lets them wake workers:")} ${D("their requests can start an agent run on this machine while you are away (you chose wake \"anyone\"). Take it back: pantheon admit <name> --revoke")}`
+                    : D(`  It lets them join and talk to your agent. It does not let them wake this machine on its own: the first time their request needs it while you are away, you are asked (Always / Just this once / No). Approve ahead: pantheon wake allow <name>`));
                 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 ${link ?? r.invite}`)}`);
+                console.error(`  ${D("Tell your agent: read")} ${C("https://www.joinpantheon.network/skills/join.md")} ${D("and follow it. Invite:")} ${C(`pantheon join ${link ?? r.invite}`)}`);
             }
             if (!r.reach.shareable && r.reach.hint) {
                 console.error(`\n\x1b[33m  That address only works on this machine.\x1b[0m`);
                 console.error(D(`  ${r.reach.hint}`));
             }
+            if (r.claimed) {
+                await bindReposHere(argv.includes("--yes"));
+                await workerAfterBinding(wp.how);
+            }
             printReady(r.tools);
             if (r.claimed)
-                await guidedSetup(load() ?? r.cfg, repoInfo(process.cwd())?.root ?? null, { preset: setupFlags.preset, force: Object.keys(setupFlags.preset).length > 0 || argv.includes("--yes") });
+                await guidedSetup(load() ?? r.cfg, repoInfo(process.cwd())?.root ?? null, { preset: setupFlags.preset, force: Object.keys(setupFlags.preset).length > 0 || argv.includes("--yes"), founder: true });
             if (r.relay) {
                 console.error(D(`\nKeeping the relay running here. Ctrl-C stops it (your teammate goes offline too).`));
                 await new Promise(() => { });
@@ -774,11 +1174,11 @@ async function main() {
                 for (const i of open)
                     console.log(`${i.mine ? C(i.token) : D(i.token)}  by ${i.created_by}  expires ${new Date(i.expires_at).toLocaleString()}${i.may_wake ? "  may wake" : ""}${i.mine ? "" : D("  (not yours — masked)")}`);
                 if (open.length)
-                    console.log(D(`\nrevoke one: pantheon invite --revoke <token or its last 6 characters>   ·   all of yours: pantheon invite --revoke all`));
+                    console.log(D(`\nrevoke one: pantheon invite --revoke <token or its last 6 characters>${teamFlag(cfg)}   ·   all of yours: pantheon invite --revoke all${teamFlag(cfg)}`));
                 client.close();
                 return;
             }
-            const ttl = Number(flag("ttl", "1440"));
+            const ttl = numFlag("ttl", 1440);
             const mayWake = argv.includes("--may-wake") ? true : argv.includes("--no-wake") ? false : wakeDefault(loadProfile(cfg));
             const inv = await client.makeInvite(mayWake, ttl).catch((e) => die(e.message));
             const raw = toInvite({ ...cfg, token: inv.url });
@@ -788,13 +1188,29 @@ async function main() {
                 console.error(`\n${D("Or send this — it unfurls in chat with the team's name, and pantheon join accepts it too:")}\n  ${C(link)}`);
             console.error(D(`\nSingle use, expires ${new Date(inv.expires_at).toLocaleString()}.`));
             console.error(D(`For a teammate who is not technical, forward this 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 ${link ?? raw}`)}`);
+            console.error(`  ${D("Tell your agent: read")} ${C("https://www.joinpantheon.network/skills/join.md")} ${D("and follow it. Invite:")} ${C(`pantheon join ${link ?? raw}`)}`);
             client.close();
             return;
         }
         case "relay": {
+            for (const s of [process.stdout, process.stderr])
+                s.on("error", () => { });
             process.on("unhandledRejection", (e) => { console.error(`! unhandled rejection: ${e?.stack ?? String(e)}`); });
-            process.on("uncaughtException", (e) => { console.error(`! uncaught exception (kept serving): ${e?.stack ?? String(e)}`); });
+            for (const s of [process.stdout, process.stderr])
+                s.on("error", () => { });
+            let inHandler = false;
+            process.on("uncaughtException", (e) => {
+                if (e?.code === "EPIPE" || e?.code === "ERR_STREAM_DESTROYED" || inHandler)
+                    return;
+                inHandler = true;
+                try {
+                    console.error(`! uncaught exception (kept serving): ${e?.stack ?? String(e)}`);
+                }
+                catch { }
+                finally {
+                    inHandler = false;
+                }
+            });
             const relay = new Relay({
                 port: Number(flag("port", process.env.PORT ?? "8787")),
                 host: flag("host", "0.0.0.0"),
@@ -805,7 +1221,7 @@ async function main() {
             console.error(D(`ledger:     ${resolveDataDir(flag("data")).dir}`));
             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.`));
+            console.error(D(`then, on your own machine: pantheon start --relay <this address>, and send them what pantheon invite prints. Ctrl-C to stop.`));
             let shuttingDown = false;
             const shutdown = async (sig) => {
                 if (shuttingDown)
@@ -878,7 +1294,8 @@ async function main() {
             catch (e) {
                 if (!looksLikeInviteCode(invite))
                     die(e.message);
-                const candidates = [flag("relay"), process.env.PANTHEON_RELAY, load()?.relay, DEFAULT_RELAY].filter((r) => !!r);
+                const named = flag("relay") ?? process.env.PANTHEON_RELAY;
+                const candidates = (named ? [named] : [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`));
             }
@@ -901,21 +1318,59 @@ async function main() {
                 const m = e.message;
                 if (/BAD_INVITE/.test(m)) {
                     const body = m.replace(/^BAD_INVITE:\s*/, "");
-                    die(/\n/.test(body) ? body : `${body}\n  Ask your teammate for a fresh one: pantheon invite`);
+                    die(/\n/.test(body) || /fresh one|new invite/i.test(body) ? body : `${body}\n  Ask your teammate for a fresh one: pantheon invite`);
                 }
                 if (/NO_SUCH_SPACE/.test(m))
-                    die(`${m}\n  Their relay may not be running, or the link points somewhere else.`);
+                    die(`${m}\n  The relay answered, but has no team by that name — it was deleted, or the link was copied from somewhere else. Ask your teammate for a fresh invite.`);
                 if (/ECONNREFUSED|ENOTFOUND|timeout/i.test(m))
                     die(`cannot reach the relay in that invite.\n  ${m}\n  Is their relay still running, and are you both on the same network/tailnet?`);
-                die(m);
+                die(m + (/NOT_SIGNED_IN/.test(m) ? signInHint("NOT_SIGNED_IN", parsed.relay) : ""));
             });
             for (const t of r.tools)
                 console.error(`  ${t.tool.padEnd(14)}${t.status}`);
             for (const w of r.warnings)
-                console.error(`\x1b[33m  ! ${w}\x1b[0m`);
+                console.error(`\x1b[33m  ! ${w}\x1b[0m` + (/NOT_SIGNED_IN/.test(w) ? signInHint("NOT_SIGNED_IN", parsed.relay) : ""));
             printGranted(r.granted);
+            printRelayNote(r.cfg?.relay ?? parsed.relay);
             rememberWorkingProxy();
             printReady(r.tools);
+            {
+                const jc = load();
+                const mode = jc ? wakeMode(loadProfile(jc)) : "anyone";
+                console.error(D(mode === "anyone"
+                    ? `\n  Your teammates can hand work to this machine while you're away, so nothing waits on you. To approve each teammate first: pantheon setup --wake approved`
+                    : mode === "no"
+                        ? `\n  This machine is set not to be woken: teammates' requests wait for you. Change it: pantheon setup`
+                        : `\n  The first time a teammate's request needs this machine while you are away, you are asked — "Always / Just this once / No" in the menu bar. Approve someone ahead: pantheon wake allow <name>`));
+            }
+            if (process.stdin.isTTY)
+                await bindReposHere(false);
+            {
+                const j = load();
+                let teamRepos = [];
+                if (j) {
+                    const { repo: _r, repoOrigin: _o, ...plain } = j;
+                    const c = new PantheonClient(plain, undefined, { role: "cli" });
+                    try {
+                        await Promise.race([c.connect(), new Promise((_, no) => setTimeout(() => no(new Error("timeout")), 8000))]);
+                        await new Promise((res) => setTimeout(res, 150));
+                        teamRepos = c.repos.map((r) => ({ fingerprint: r.fingerprint, origin: r.origin ?? null }));
+                    }
+                    catch { }
+                    finally {
+                        c.close();
+                    }
+                }
+                const all = loadAll();
+                const m = all && j ? findMembership(all, j.spaceId ?? j.space) ?? findMembership(all, j.space) : null;
+                if (!teamRepos.length && m?.repos?.length)
+                    teamRepos = m.repos.map((r) => ({ fingerprint: r.fp, origin: r.name }));
+                if (all && m && teamRepos.length) {
+                    console.error("");
+                    await findAndBindRepos(all, m, teamRepos, { auto: !process.stdin.isTTY }).catch(() => { });
+                }
+            }
+            await workerAfterBinding(wp.how);
             {
                 const joined = load();
                 if (joined)
@@ -1070,6 +1525,8 @@ async function main() {
             return;
         }
         case "setup": {
+            if (inWokenRun() && !argv.includes("--questions"))
+                die("a woken run cannot change this machine's setup — a person has to run this here");
             if (argv.includes("--questions")) {
                 console.log(questionnaire());
                 return;
@@ -1104,15 +1561,20 @@ async function main() {
                 console.log(B("members"));
                 if (!peers.length)
                     console.log(`  ${D("(nobody else yet — send them an invite from `pantheon invite`)")}`);
+                const seens = peers.map((p) => p.seen_seq).filter((x) => x !== undefined && x < client.head);
+                const since = seens.length ? Math.min(...seens) : null;
+                const recent = since === null ? [] : await fetchHistory(cfg, { since }).catch(() => null);
                 for (const p of peers) {
-                    const behind = p.seen_seq === undefined ? null : client.head - p.seen_seq;
+                    const lag = p.seen_seq === undefined ? null : client.head - p.seen_seq;
+                    const behind = lag === null ? null : lag <= 0 ? 0
+                        : recent ? recent.filter((a) => a.seq > p.seen_seq && a.from === cfg.member && a.act !== "JOIN" && a.act !== "LEAVE" && !a.meta?.organization_profile).length : lag;
                     const reach = behind === null
                         ? D(p.delivered_seq !== undefined && p.delivered_seq >= client.head
                             ? "delivered, but no read-receipt — no wake-up hook on their machine"
                             : "no wake-up hook on their machine — nothing surfaces until their human types")
                         : behind > 0
-                            ? `\x1b[33mtheir agent has not seen your last ${behind} act${behind === 1 ? "" : "s"}\x1b[0m`
-                            : D("their agent is caught up");
+                            ? `\x1b[33m${recent ? `their agent has not seen your last ${behind} act${behind === 1 ? "" : "s"}` : `their agent is ${behind} act${behind === 1 ? "" : "s"} behind the team`}\x1b[0m`
+                            : lag > 0 ? D("their agent has seen everything you sent") : D("their agent is caught up");
                     console.log(`  ${p.online ? C("●") : D("○")} ${p.id.padEnd(14)} ${D(p.agent.padEnd(12))} ${reach}`);
                 }
                 const goals = [...client.goals.values()];
@@ -1135,6 +1597,12 @@ async function main() {
                 for (const o of human) {
                     const who = o.owner.replace(/^human:/, "");
                     const stale = Date.now() - o.created_at > 3_600_000;
+                    const askAct = client.seenAct(o.ref);
+                    const wakeAsk = askAct?.from === who ? askAct.meta?.wake_ask : undefined;
+                    if (who !== cfg.member && typeof wakeAsk === "string") {
+                        console.log(`  ${who.padEnd(14)}${ageOf(o.created_at).padEnd(6)} ${D(`is being asked on their machine whether ${wakeAsk === cfg.member ? "you" : wakeAsk} may start work there while they are away`)}`);
+                        continue;
+                    }
                     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")}`);
@@ -1175,7 +1643,7 @@ async function main() {
                     owed: client.myObligations().map((o) => ({
                         id: o.id, kind: o.kind, body: o.body, created_at: o.created_at,
                     })),
-                    recentRuns: recentRuns(86_400_000),
+                    recentRuns: recentRuns(86_400_000, undefined, 12, { teams: [client.spaceId, cfg.spaceId, cfg.space], member: cfg.member }),
                 }));
                 client.close();
             }
@@ -1218,16 +1686,14 @@ async function main() {
                     console.log(`             ${line}`);
                 console.log();
             };
-            const base = cfg.relay.replace(/^ws/, "http").replace(/\/+$/, "");
-            const q = `space=${encodeURIComponent(cfg.space)}&token=${encodeURIComponent(cfg.token)}`;
-            const first = await fetch(`${base}/history?${q}`).catch((e) => die(describeNetError(e, cfg.relay)));
+            const first = await signedRead(cfg, "/history").catch((e) => die(describeNetError(e, cfg.relay)));
             if (!first.ok)
-                die(`relay answered ${first.status} — check the space name and token`);
+                die((await readFailure(cfg, first, "the ledger")).message);
             let since = ((await first.json()).acts ?? []).at(-1)?.seq ?? 0;
             console.log(`${B("watching")} ${cfg.space} ${D("(ctrl-c to stop)")}\n`);
             for (;;) {
                 await new Promise((r) => setTimeout(r, LIMITS.watchPollMs));
-                const res = await fetch(`${base}/history?${q}&since=${since}`).catch(() => null);
+                const res = await signedRead(cfg, "/history", { since }).catch(() => null);
                 if (!res?.ok)
                     continue;
                 for (const act of (await res.json()).acts ?? []) {
@@ -1242,6 +1708,8 @@ async function main() {
             if (!report) {
                 if (argv.includes("--json"))
                     console.log(JSON.stringify({ seq: 0, acts: [], obligations: [] }));
+                else if (process.stderr.isTTY)
+                    console.error(D(`nothing new for this session${load() ? "" : " — this folder resolves to no team (pantheon status says why)"}`));
                 return;
             }
             console.log(argv.includes("--json") ? JSON.stringify(report) : renderPending(report));
@@ -1276,7 +1744,8 @@ async function main() {
             }
             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>`));
+            const pool = argv.includes("--presence") ? acts.length : acts.filter((a) => a.act !== "JOIN" && a.act !== "LEAVE").length;
+            console.log(D(`${picked.length} of ${pool} acts${argv.includes("--presence") ? " (joins and leaves included)" : ""} · --last N · --goal <id> · --from <member> · --short · --json  ·  reply: pantheon say ANSWER "…" --ref <id or seq>`));
             return;
         }
         case "show": {
@@ -1292,13 +1761,66 @@ async function main() {
             }
             return;
         }
+        case "goal": {
+            const cfg = need();
+            const sub = argv[1] ?? "list";
+            const client = new PantheonClient(cfg, undefined, { role: "cli" });
+            await client.connect().catch((e) => die(connectFailure(e, cfg.relay)));
+            try {
+                if (sub === "list") {
+                    const open = [...client.goals.values()].filter((g) => g.state !== "CLOSED");
+                    if (!open.length)
+                        console.log(D("no open goals — pantheon goal open \"<what it is about>\" --with <member>"));
+                    for (const g of open)
+                        console.log(`  ${g.id}  ${g.state.padEnd(8)} ${g.title}  ${D(`with ${g.members.join(", ")} · ${g.acts}/${g.budget} acts`)}`);
+                    return;
+                }
+                if (sub === "open") {
+                    const VALUE_FLAGS = new Set(["--with", "--acceptance", "--deadline", "--space"]);
+                    const title = argv.slice(2).filter((a, i, all) => !a.startsWith("--") && !(i > 0 && VALUE_FLAGS.has(all[i - 1]))).join(" ").trim()
+                        || die('usage: pantheon goal open "<what it is about>" --with <member>[,<member>] [--acceptance "<what done looks like>"] [--deadline <ISO time>] [--list]');
+                    const withs = cleanList((flag("with") ?? "").split(","));
+                    const dl = flag("deadline");
+                    const deadline = dl ? Date.parse(dl) : undefined;
+                    if (dl && !Number.isFinite(deadline))
+                        die(`--deadline takes a time like 2026-10-01T17:00:00Z, not "${dl}"`);
+                    const g = await client.openGoal({ title, acceptance: flag("acceptance") ?? "", ...(withs.length ? { invite: withs } : {}),
+                        ...(deadline ? { deadline } : {}), ...(argv.includes("--list") ? { kind: "worklist" } : {}) }).catch((e) => die(e.message));
+                    console.log(`opened ${g.id}  "${title}"${withs.length ? ` with ${withs.join(", ")}` : ""}`);
+                    console.error(D(`  now:  pantheon say ASK "…" --to <member> --goal ${g.id}`));
+                    return;
+                }
+                if (sub === "close") {
+                    const id = argv[2] ?? die('usage: pantheon goal close <goal id> "<what was done>"');
+                    const summary = argv.slice(3).filter((a) => !a.startsWith("--")).join(" ").trim() || die("say what was done: it is the goal's record");
+                    const r = await client.send({ act: "CLOSE", body: summary, goal: id }).catch((e) => die(e.message));
+                    console.log(`closed ${id} (act ${r.id})`);
+                    return;
+                }
+                die("usage: pantheon goal list | open \"<title>\" --with <member> | close <id> \"<summary>\"");
+            }
+            finally {
+                client.close();
+            }
+        }
         case "say": {
             const cfg = need();
             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 sayable = ACTS.filter((a) => a !== "JOIN" && a !== "LEAVE");
+                if (!sayable.includes(act))
+                    die(`"${argv[1]}" is not an act. One of: ${sayable.join(", ")}`);
+            }
             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 SAY_FLAGS = new Set([...COMMAND_FLAGS["say"].matchAll(/--([a-z][a-z-]*)/g)].map((m) => m[1]));
+                const stray = argv.slice(stop === -1 ? argv.length : stop).find((a) => /^--[a-z]/i.test(a) && !SAY_FLAGS.has(a.slice(2).toLowerCase()) && a !== "--help");
+                if (stray)
+                    die(`${stray} is not a flag of say, so it reads as part of your message — and the message would have stopped before it. Put the whole message in quotes: pantheon say ${act} "…"`);
+            }
             const summary = flag("summary");
             const client = new PantheonClient(cfg, undefined, { role: "cli" });
             await client.connect().catch((e) => die(connectFailure(e, cfg.relay)));
@@ -1316,15 +1838,25 @@ async function main() {
             let ref = flag("ref") ?? null;
             if (ref !== null || ["ANSWER", "ACCEPT", "OBJECT"].includes(act)) {
                 let acts;
+                let settled = null;
+                let answered = new Set();
                 if (ref && ref !== "last") {
                     const hit = (await fetchAct(cfg, ref))?.act;
                     acts = hit ? [hit] : [];
-                    if (!hit && /^a_/.test(ref))
-                        console.error(D(`  ${ref} is not in what this relay holds — sending it as given`));
                 }
-                else
+                else {
                     acts = await fetchHistory(cfg, goalArg ? { goal: goalArg } : {}).catch(() => []);
+                    answered = new Set(acts.filter((a) => a.from === cfg.member && a.ref).map((a) => a.ref));
+                    const closed = new Set([...client.goals.values()].filter((g) => g.state === "CLOSED").map((g) => g.id));
+                    const all = acts;
+                    acts = acts.filter((a) => !answered.has(a.id) && !(a.goal && closed.has(a.goal)));
+                    settled = all.filter((a) => a.from !== cfg.member && (answered.has(a.id) || (!!a.goal && closed.has(a.goal))) && (!a.to?.length || a.to.includes(cfg.member))).at(-1) ?? null;
+                }
                 const rr = resolveRef(acts, ref, act, goalArg, cfg.member);
+                if (rr.error && settled) {
+                    client.close();
+                    die(`${rr.error}\n  The latest one to you, [${settled.seq}] ${settled.act} from ${settled.from}, is already ${answered.has(settled.id) ? "answered" : "in a closed goal"} — to answer it again: --ref ${settled.seq}`);
+                }
                 if (rr.error) {
                     client.close();
                     die(rr.error);
@@ -1341,8 +1873,17 @@ async function main() {
                 ref,
                 ...(summary ? { summary } : {}),
                 ...(Object.keys(meta).length ? { meta } : {}),
-            }).catch((e) => die(/SUMMARY_REQUIRED/.test(e.message) ? `${e.message}\n  Add one: --summary 'the point they must not miss'` : e.message));
+            }).catch((e) => die(/SUMMARY_REQUIRED/.test(e.message) ? `${e.message}\n  Add one: --summary 'the point they must not miss'`
+                : /UNVERIFIABLE_DELIVERY/.test(e.message) ? `${e.message}\n  From here: pantheon say DELIVERED "…" --branch <the pushed branch> --commit <its sha>`
+                    : /BAD_REF/.test(e.message) ? `${e.message}\n  pantheon history lists the acts with their ids and [sequence numbers]; --ref takes either, or "last"`
+                        : /TO_REQUIRED/.test(e.message) ? `${e.message}\n  Name who owes it: --to <member>   (pantheon team lists them)`
+                            : /GOAL_REQUIRED|NO_SUCH_GOAL|GOAL_CLOSED/.test(e.message) ? `${e.message.replace(/ — open one with pantheon_open_goal/, "").replace(/pantheon_open_goal/g, "pantheon goal open")}\n  Open one from here:  pantheon goal open "<what it is about>" --with <member>   then add --goal <id>   (pantheon goal list shows the open ones)`
+                                : e.message));
             console.log(`sent ${act} id=${r.id} seq=${r.seq}`);
+            if (flag("space"))
+                console.error(D(`  in "${cfg.space}"`));
+            else if (resolveFor(process.cwd()).reason === "default")
+                console.error(D(`  in "${cfg.space}" — your default team; this folder is bound to none (pantheon use <team> --here)`));
             client.close();
             return;
         }
@@ -1374,7 +1915,7 @@ async function main() {
             }
             if (worker.running) {
                 console.log(`  worker    ${C("running")}   ${worker.managedBy === "launchd" ? `service ${worker.label}` : "started by hand"}   pid ${worker.pid}`);
-                console.log(`            ${D("a peer you granted --may-wake can start an agent run here")}`);
+                console.log(`            ${D("a teammate approved on this machine (pantheon wake list) can start an agent run here")}`);
             }
             else {
                 console.log(`  worker    ${D("not running")}   ${D("nobody can start an agent run on this machine")}`);
@@ -1453,9 +1994,10 @@ async function main() {
             if (!["all", "relay", "worker", "notifier", "menubar"].includes(what))
                 die(`usage: pantheon stop [relay|worker|notifier|menubar|all]`);
             const { stopMachine } = await import("./machine.js");
+            const { killRecordedRun } = await import("./worker.js");
             console.log(B("stopping"));
             const everyTeam = Object.values(loadAll()?.spaces ?? {}).map((m) => ({ name: m.name, relay: m.relay }));
-            const res = stopMachine(what, { port: Number(flag("port", "8787")), teams: everyTeam.length ? everyTeam : (load()?.relay ? [{ name: load().space, relay: load().relay }] : []) });
+            const res = stopMachine(what, { port: Number(flag("port", "8787")), teams: everyTeam.length ? everyTeam : (load()?.relay ? [{ name: load().space, relay: load().relay }] : []), killRun: () => killRecordedRun(dirname(CONFIG_PATH)) });
             for (const l of res.lines)
                 console.log(`  ${l}`);
             if (res.note)
@@ -1470,12 +2012,21 @@ async function main() {
                 die(`no ${kind} log found. ${process.platform === "linux" ? `If it runs as a service: journalctl --user -u pantheon-${kind}` : process.platform === "darwin" ? "If it runs as a service, the plist names the path" : "Services are not used on Windows"}; if you started it by hand, its output went to that terminal.`);
             console.error(D(`${f}  (${statFile(f)})\n`));
             const follow = argv.includes("-f") || argv.includes("--follow");
-            const { spawn } = await import("node:child_process");
-            spawn("tail", [...(follow ? ["-f"] : []), "-n", flag("n", "40"), f], { stdio: "inherit" });
+            const { tailLines, followFile } = await import("./machine.js");
+            process.stdout.write(tailLines(f, Math.max(0, Number(flag("n", "40")) || 40)));
+            if (follow)
+                await followFile(f, (chunk) => process.stdout.write(chunk));
             return;
         }
         case "hook": {
             const sub = argv[1] ?? "status";
+            if (inWokenRun() && !["install", "uninstall", "remove", "status"].includes(sub)) {
+                if (sub === "cursor-prompt")
+                    console.log(JSON.stringify({ continue: true }));
+                else if (sub === "cursor-stop")
+                    console.log("{}");
+                process.exit(0);
+            }
             const hookCfg = resolveForHook();
             const sessionOf = (raw) => {
                 let fromJson;
@@ -1573,7 +2124,8 @@ async function main() {
                 catch { }
                 try {
                     const { reportActivity } = await import("./pending.js");
-                    await reportActivity({ session: `hook:${session}`, state: "busy" });
+                    if (hookCfg)
+                        await reportActivity({ cfg: hookCfg, session: `hook:${session}`, state: "busy" });
                 }
                 catch { }
                 console.log(JSON.stringify({ continue: true }));
@@ -1761,7 +2313,7 @@ async function main() {
             client.close();
             const bound = Object.values(all.bindings ?? {}).filter((b) => b.space === m.id).length;
             removeMembership(m.id);
-            console.error(`${B("deleted")} "${m.name}" — everyone in it was disconnected; its token${bound ? ` and ${bound} repo binding${bound === 1 ? "" : "s"}` : ""} left this machine`);
+            console.error(`${B("deleted")} "${m.name}" — everyone in it was disconnected; its token${bound ? ` and ${bound} folder binding${bound === 1 ? "" : "s"}` : ""} left this machine`);
             return;
         }
         case "leave": {
@@ -1769,9 +2321,21 @@ async function main() {
                 const all = loadAll() ?? die("not configured");
                 const m = findMembership(all, argv[1]) ?? die(`you are not in a team called "${argv[1]}". Yours: ${Object.values(all.spaces ?? {}).map((x) => x.name).join(", ") || "none"}`);
                 const bound = Object.values(all.bindings ?? {}).filter((b) => b.space === m.id).map((b) => b.origin ?? b.path);
+                const { others, founder } = await teamStanding(all, m);
+                if (founder && others?.length === 0 && !argv.includes("--yes")) {
+                    die(`you founded "${m.name}" and nobody else is in it. Leaving keeps it on the relay — holding your plan's team slot — and takes away the only way to delete it.\n` +
+                        `  Delete it instead:   pantheon space delete ${m.name} --yes\n  Leave it anyway:     pantheon leave ${m.name} --yes`);
+                }
                 removeMembership(m.id);
-                console.error(`${B("left")} "${m.name}" — its token is gone from this machine${bound.length ? `, and ${bound.length} repo binding${bound.length === 1 ? "" : "s"} with it (${bound.join(", ")})` : ""}.`);
-                console.error(D(`Your teammates still list you in "${m.name}". Ask one of them to run:  pantheon admit ${m.name === all.member ? "you" : all.member} --revoke   if you are not coming back.`));
+                console.error(`${B("left")} "${m.name}" — its token is gone from this machine${bound.length ? `, and ${bound.length} binding${bound.length === 1 ? "" : "s"} with it (${bound.join(", ")})` : ""}.`);
+                if (others === null)
+                    console.error(D(`The relay could not be reached to check who else is in "${m.name}". If there are teammates, they still list you; one of them removes you with: pantheon admit ${all.member} --revoke`));
+                else if (others.length)
+                    console.error(D(founder
+                        ? `${others.join(", ")} ${others.length === 1 ? "is" : "are"} still in "${m.name}", with you as its founder — a founder cannot be removed by the others. To come back, ask one of them for an invite.`
+                        : `${others.join(", ")} still list you in "${m.name}". If you are not coming back, one of them runs:  pantheon admit ${all.member} --revoke`));
+                else
+                    console.error(D(`Nobody else was in "${m.name}"; it stays on the relay until its founder deletes it.`));
                 return;
             }
             const all = loadAll();
@@ -1780,24 +2344,43 @@ async function main() {
             const plan = leavePlan(all);
             const project = resolve(flag("project", "."));
             const keepIdentity = argv.includes("--keep-identity");
-            if (plan.teams.length > 1 && !keepIdentity && !argv.includes("--yes")) {
+            const standing = new Map();
+            if (all && !keepIdentity) {
+                const ms = Object.values(all.spaces ?? {});
+                const got = await Promise.all(ms.map((m) => teamStanding(all, m)));
+                ms.forEach((m, i) => standing.set(m.name, got[i]));
+            }
+            const stranded = [...standing].filter(([, v]) => v.founder && v.others?.length === 0).map(([k]) => k);
+            if (stranded.length && !argv.includes("--yes")) {
+                die(`you founded ${stranded.map((t) => `"${t}"`).join(", ")} and nobody else is in ${stranded.length === 1 ? "it" : "them"}. Leaving keeps ${stranded.length === 1 ? "it" : "them"} on the relay — holding your plan's team slot — and takes away the only way to delete ${stranded.length === 1 ? "it" : "them"}.\n` +
+                    `  Delete first:     ${stranded.map((t) => `pantheon space delete ${t} --yes`).join("  ·  ")}\n  Leave anyway:     pantheon leave --yes`);
+            }
+            const orphaned = [...standing].filter(([, v]) => v.founder && (v.others?.length ?? 0) > 0).map(([k]) => k);
+            if (orphaned.length && !argv.includes("--yes")) {
+                die(`you founded ${orphaned.map((t) => `"${t}"`).join(", ")}, and others are in ${orphaned.length === 1 ? "it" : "them"}. Leaving removes this machine's key: you could not rejoin as yourself, and only a founder can remove a member or delete a team — nobody there could, ever again.\n` +
+                    `  To step out but keep the way back:  ${orphaned.map((t) => `pantheon leave ${t}`).join("  ·  ")}   (keeps your key)\n  Leave anyway:  pantheon leave --yes`);
+            }
+            if (plan.teams.length && !keepIdentity && !argv.includes("--yes")) {
                 const list = plan.teams.map((t) => `"${t.name}"`).join(", ");
+                const what = plan.teams.length > 1 ? `this machine is in ${plan.teams.length} teams — ${list}. Leaving removes its key, so it leaves ALL of them.` : `this removes Pantheon and this machine's key, so it leaves ${list}.`;
                 if (!process.stdin.isTTY)
-                    die(`this machine is in ${plan.teams.length} teams — ${list}. Leaving removes its key, so it leaves ALL of them.\n  If you mean it:  pantheon leave --yes\n  Just one team:   pantheon leave <team>`);
+                    die(`${what}\n  If you mean it:  pantheon leave --yes${plan.teams.length > 1 ? "\n  Just one team:   pantheon leave <team>" : ""}`);
                 const rl = createInterface({ input: process.stdin, output: process.stderr });
-                const answer = await new Promise((res) => rl.question(`This machine is in ${plan.teams.length} teams: ${list}. Leaving removes its key, so it leaves ALL of them. Type "yes" to continue: `, (x) => res(x.trim())));
+                const answer = (await questionOrNull(rl, `${what[0].toUpperCase()}${what.slice(1)} Type "yes" to continue: `)) ?? "";
                 rl.close();
                 if (answer.toLowerCase() !== "yes")
-                    die(`nothing was changed. Leave one team with: pantheon leave <team>`);
+                    die(`nothing was changed.${plan.teams.length > 1 ? " Leave one team with: pantheon leave <team>" : ""}`);
             }
             console.error(`${B("leaving pantheon")}${plan.teams.length ? D(`   — ${plan.teams.map((t) => t.name).join(", ")}`) : ""}\n`);
             const { uninstallMachine, realUninstallIo } = await import("./machine.js");
             const { removeUserMcpEntries } = await import("./install.js");
+            const { killRecordedRun } = await import("./worker.js");
             const done = uninstallMachine({ project, stopRelay: argv.includes("--stop-relay") }, realUninstallIo({
                 port: Number(flag("port", "8787")),
                 removeMcpEntries: () => removeUserMcpEntries({ project }),
                 hasIntent: () => readIntent() !== null,
                 clearIntent: () => clearIntent(),
+                killRun: () => killRecordedRun(dirname(CONFIG_PATH)),
             }));
             for (const l of done.lines)
                 console.error(`  ${l}`);
@@ -1858,6 +2441,20 @@ async function main() {
                             left.push(`${join(dir, "quarantine-kept")} — agent config an interrupted run held, set aside because the repo had moved on; check it, then delete the folder`);
                 }
             }
+            {
+                const { removePantheonWorktrees, removeHomeLeftovers } = await import("./machine.js");
+                const repos = [project, ...Object.values(all?.bindings ?? {}).map((b) => b.path).filter((p) => !!p)];
+                const trees = removePantheonWorktrees(repos, [join(CONFIG_DIR, "worktrees"), ...repos.map((r) => join(r, ".pantheon", "worktrees"))]);
+                removed.push(...trees.removed);
+                left.push(...trees.left);
+                try {
+                    rmSync(join(CONFIG_DIR, "worktrees"), { recursive: true, force: true });
+                }
+                catch { }
+                const rest = removeHomeLeftovers(CONFIG_DIR, keepIdentity);
+                removed.push(...rest.removed);
+                left.push(...rest.left);
+            }
             console.error(`\n${B("Removed")}`);
             for (const r of removed)
                 console.error(`  ${C("✓")} ${r}`);
@@ -1868,9 +2465,20 @@ async function main() {
                 console.error(`  • ${l}`);
             console.error(`  • ${D("files committed in your repos (.mcp.json, .cursor/mcp.json, .vscode/mcp.json, the brief in AGENTS.md / CLAUDE.md) — your team's; delete them in a commit if the whole team is leaving")}`);
             console.error(`  • ${D("the relay's ledger on disk, and anything you pushed to git")}`);
-            if (plan.teams.length) {
-                console.error(`\n  ${D(`Your teammates still list you in ${plan.teams.map((t) => `"${t.name}"`).join(", ")}. Ask someone in each to run:`)}`);
-                console.error(`  ${D(`pantheon admit ${me?.member ?? plan.member ?? "<your name>"} --revoke`)}`);
+            {
+                const name = me?.member ?? plan.member ?? "<your name>";
+                const listed = plan.teams.filter((t) => { const s = standing.get(t.name); return !s || s.others === null || (s.others.length && !s.founder); }).map((t) => `"${t.name}"`);
+                const founded = plan.teams.filter((t) => { const s = standing.get(t.name); return s?.founder && s.others?.length; }).map((t) => `"${t.name}"`);
+                if (listed.length) {
+                    console.error(`\n  ${D(`Your teammates may still list you in ${listed.join(", ")}. If you are not coming back, ask one in each to run:`)}`);
+                    console.error(`  ${D(`pantheon admit ${name} --revoke`)}`);
+                }
+                if (founded.length)
+                    console.error(`\n  ${D(`You founded ${founded.join(", ")}. With this machine's key gone you cannot rejoin as yourself, and nobody there can remove a member or delete the team — only its founder could.`)}`);
+            }
+            if (me?.account && !keepIdentity) {
+                const { accountStillExists } = await import("./machine.js");
+                console.error(`\n  ${accountStillExists(me.account.email)}`);
             }
             console.error(`\n  ${D(`If Pantheon let you down, one line on why to ${FEEDBACK_ADDRESS} would help more than you might think.`)}`);
             return;
@@ -1884,6 +2492,12 @@ async function main() {
         }
         case "panic": {
             console.error(`${B("PANIC — locking down this machine")}\n`);
+            {
+                const { killRecordedRun } = await import("./worker.js");
+                const killed = killRecordedRun(dirname(CONFIG_PATH));
+                if (killed)
+                    console.error(`  ${killed}`);
+            }
             const { panicMachine, waitStopped } = await import("./machine.js");
             const all = loadAll();
             const teams = Object.values(all?.spaces ?? {});
@@ -1921,11 +2535,27 @@ async function main() {
             await client.connect().catch((e) => die(client.pending ?? connectFailure(e, cfg.relay)));
             await new Promise((r) => setTimeout(r, 300));
             console.log(`${B(`who is in ${cfg.space}`)}\n`);
+            const { loadPolicy, isApprovedWaker, relayKnowsAdmitters } = await import("./worker-policy.js");
+            const { wakeMode } = await import("./profile.js");
+            const pol = loadPolicy();
+            const keys = [client.spaceId ?? cfg.spaceId, cfg.space];
+            const carried = keys.some((k) => !!k && !!pol.wakersCarried?.[k]);
+            const mode = wakeMode(loadProfile(cfg)) === "approved" && !carried && !relayKnowsAdmitters(client.members, cfg.member) ? "anyone" : wakeMode(loadProfile(cfg));
             for (const e of client.members) {
                 const who = e.member.padEnd(16);
                 const you = e.member === cfg.member ? D(" (you)") : "";
                 if (e.admitted) {
-                    console.log(`  ${C("in")}       ${who}${e.may_wake ? "can start work here while you are away" : D("cannot start work here")}${you}`);
+                    const team = D(e.may_wake ? "   team: may wake workers" : "   team: may not wake workers");
+                    const here = e.member === cfg.member ? ""
+                        : mode === "no" ? D("cannot start work here — this machine is set not to be woken")
+                            : mode === "anyone" ? (e.may_wake ? "can start work here while you are away" : D("cannot start work here"))
+                                : isApprovedWaker(pol, keys, e.member)
+                                    ? (e.may_wake ? "can start work here while you are away (approved here)" : D("approved here, but the team does not let them wake workers yet"))
+                                    : D(`cannot start work here — pantheon wake allow ${e.member}${teamFlag(cfg)}`);
+                    console.log(`  ${C("in")}       ${who}${here}${e.member === cfg.member ? "" : team}${you}`);
+                }
+                else if (e.revoked_at) {
+                    console.log(`  ${D("removed")}  ${who}${D(`removed${e.revoked_by ? ` by ${e.revoked_by}` : ""}, ${new Date(e.revoked_at).toLocaleString()}`)}`);
                 }
                 else {
                     console.log(`  \x1b[33mwaiting\x1b[0m  ${who}${D(`fingerprint ${e.fingerprint}`)}`);
@@ -1936,37 +2566,58 @@ async function main() {
             return;
         }
         case "admit": {
+            if (inWokenRun())
+                die("a woken run cannot admit anyone or change who may wake this machine — a person has to run this here");
             const cfg = need();
-            const who = argv[1] ?? die("usage: pantheon admit <member> [--may-wake] [--revoke] [--forget]");
+            const who = argv[1] ?? die("usage: pantheon admit <member> [--may-wake | --no-wake] [--revoke] [--forget] [--yes]");
+            const forget = argv.includes("--forget");
+            const revoke = argv.includes("--revoke");
+            const askedWake = argv.includes("--may-wake") && !revoke && !forget;
+            if (askedWake && !argv.includes("--yes") && !process.stdin.isTTY) {
+                die(`--may-wake lets ${who} start agent runs for the team, and there is no terminal here for a person to confirm it — pass --yes to confirm (nothing was changed)`);
+            }
             const client = new PantheonClient(cfg, undefined, { role: "cli" });
             await client.connect().catch((e) => die(client.pending ?? connectFailure(e, cfg.relay)));
             await new Promise((r) => setTimeout(r, 250));
-            const forget = argv.includes("--forget");
-            const revoke = argv.includes("--revoke");
-            const mayWake = argv.includes("--may-wake");
             const entry = client.members.find((e) => e.member === who);
             if (!entry)
                 die(`"${who}" has never connected, so there is no key to admit. Have them run \`pantheon join\` first.`);
+            const mayWake = askedWake ? true : argv.includes("--no-wake") ? false : !!(entry.admitted && entry.may_wake);
             if (!revoke && !forget) {
                 console.error(`${B("confirm this fingerprint with them directly:")}  ${C(entry.fingerprint)}`);
-                if (mayWake) {
-                    console.error(`\n${B(`--may-wake lets ${who} cause an agent to run on THIS machine:`)}`);
-                    console.error(`  ${C("can")}    read this repo, and write on pantheon/* branches only`);
+                if (askedWake) {
+                    const { COMMAND_GRANT_SCOPE } = await import("./agents.js");
+                    const { commandState } = await import("./command-state.js");
+                    const cmds = commandState({ project: process.cwd() });
+                    console.error(`\n${B(`--may-wake lets ${who} cause an agent to run on THIS machine (and on any teammate's that allows them — pantheon wake allow):`)}`);
+                    console.error(`  ${C("can")}    edit files in its own worktree of this repo, on a pantheon/* branch`);
+                    console.error(`  ${C("can")}    read files your agent's own rules let it read — for Codex that is the whole disk (its read-only sandbox limits writes, not reads)`);
                     console.error(`  ${C("can")}    reply to your peers as you, while you are away`);
-                    console.error(`  ${D("cannot")} run shell commands (unless you start the worker with --allow-bash)`);
-                    console.error(`  ${D("cannot")} touch your working tree, your other branches, or merge anything`);
+                    if (cmds.level === "off") {
+                        console.error(`  ${D("cannot")} run commands — unless a person on this machine grants that (pantheon policy grant run-commands, or answering the worker's request here) or the worker runs with --allow-bash. Then: ${COMMAND_GRANT_SCOPE}`);
+                    }
+                    else {
+                        console.error(`  ${C("can")}    run commands: ${cmds.summary}. ${COMMAND_GRANT_SCOPE}`);
+                    }
+                    console.error(`  ${D("cannot")} touch your own checkout's working tree, or merge anything`);
                     console.error(`  ${D("limits")} one run at a time, 12 per hour, and only while a worker is running`);
-                    console.error(`\n  ${D("Nothing happens at all unless you run `pantheon worker`. Undo instantly: pantheon panic")}`);
+                    console.error(`\n  ${D("Runs happen only while a worker runs here (pantheon ps shows it). Undo: pantheon wake deny " + who + " (this machine) or pantheon admit " + who + " --no-wake (the team). Emergency: pantheon panic — it also switches off wake rights in every team you are in.")}`);
                     if (argv.includes("--yes")) {
                         console.error(`  ${D("--yes given: granted without prompting.")}`);
                     }
                     else {
                         const rl = createInterface({ input: process.stdin, output: process.stderr });
-                        const ans = await new Promise((res) => rl.question(`\ngrant that to ${who}? [y/N] `, res));
+                        const ans = (await questionOrNull(rl, `\ngrant that to ${who}? [y/N] `)) ?? "";
                         rl.close();
-                        if (!/^y(es)?$/i.test(ans.trim())) {
+                        if (!/^y(es)?$/i.test(ans)) {
+                            const keep = !!(entry.admitted && entry.may_wake);
+                            if (entry.admitted) {
+                                console.error(`\nnot granted. Nothing was changed.`);
+                                client.close();
+                                return;
+                            }
                             console.error(`\nnot granted. Admitting ${who} without wake rights instead.`);
-                            await client.admit(who, false, false).catch((e) => die(e.message));
+                            await client.admit(who, keep, false).catch((e) => die(e.message));
                             console.log(`${C(who)} is in, but cannot start anything on this machine.`);
                             client.close();
                             return;
@@ -1975,13 +2626,27 @@ async function main() {
                 }
             }
             await client.admit(who, mayWake, revoke, forget).catch((e) => die(e.message));
+            let local = "";
+            const { setLocalWaker, loadPolicy: lp, isApprovedWaker: approved } = await import("./worker-policy.js");
+            const wakesHere = approved(lp(), [client.spaceId ?? cfg.spaceId, cfg.space], who);
+            if (askedWake || revoke || forget) {
+                const r = setLocalWaker([client.spaceId ?? cfg.spaceId, cfg.space], who, askedWake);
+                if (!r.ok && askedWake)
+                    local = D(`\n  Not recorded on this machine: ${r.why}.`);
+                if (r.ok && r.changed && !askedWake && wakesHere)
+                    local = D(`\n  ${who} was also taken off this machine's wake list.`);
+            }
             console.log(forget
                 ? `${C(who)} forgotten — the key ${D(entry.fingerprint)} is retired.\n` +
                     `  They can now rejoin as "${who}" with a new key, keeping their goals and obligations.\n` +
                     `  ${B("Check the new fingerprint with them")} once they are back: pantheon members`
                 : revoke
-                    ? `${C(who)} revoked — their sessions were disconnected`
-                    : `${C(who)} admitted${mayWake ? ", and may wake a worker on your machine" : " (cannot wake workers — pass --may-wake to allow)"}`);
+                    ? `${C(who)} removed from "${cfg.space}" — their sessions were disconnected${local}`
+                    : askedWake
+                        ? `${C(who)} ${entry.admitted ? `may now wake workers in "${cfg.space}"` : `admitted to "${cfg.space}", and may wake workers there`}, including on this machine${local}\n` +
+                            D(`  Each teammate decides for their own machine: pantheon wake allow ${who}`)
+                        : `${C(who)} ${entry.admitted ? `was already in "${cfg.space}"` : `admitted to "${cfg.space}"`}${mayWake ? D(" (the team still lets them wake workers)") : ""}\n` +
+                            (wakesHere ? D(`  ${who} may already wake this machine (pantheon wake list)`) : D(`  To let ${who} wake THIS machine: pantheon wake allow ${who}${teamFlag(cfg)}   (only here — nothing is sent to the team)`)));
             client.close();
             return;
         }
@@ -2015,7 +2680,7 @@ async function main() {
             const prior = identity();
             const relay = flag("relay") ?? prior?.relay ?? process.env.PANTHEON_RELAY ?? DEFAULT_RELAY;
             const kp = prior?.publicKey && prior.privateKey ? { publicKey: prior.publicKey, privateKey: prior.privateKey } : newKeypair();
-            const label = flag("label") ?? `${process.env.USER ?? "a"}'s ${process.platform === "darwin" ? "mac" : process.platform}`;
+            const label = flag("label") ?? deviceLabel();
             const base = relay.replace(/^ws/, "http").replace(/\/+$/, "");
             const body = purpose === "signup" ? { email, username, pubkey: kp.publicKey, label } : { email, pubkey: kp.publicKey, label };
             const r = await fetch(`${base}/auth/${purpose}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) })
@@ -2042,7 +2707,7 @@ async function main() {
             let code = (argv[1] ?? flag("code") ?? "").trim();
             if (!code && process.stdin.isTTY) {
                 const rl = createInterface({ input: process.stdin, output: process.stderr });
-                code = (await new Promise((res) => rl.question(`Enter the 6-digit code sent to ${pending.email}: `, res))).trim();
+                code = (await questionOrNull(rl, `Enter the 6-digit code sent to ${pending.email}: `)) ?? "";
                 rl.close();
             }
             if (!code)
@@ -2408,39 +3073,229 @@ async function main() {
             client.close();
             return;
         }
+        case "trust": {
+            const { WOKEN_RUN_ENV } = await import("./worker-policy.js");
+            const inRun = process.env[WOKEN_RUN_ENV] !== undefined || /[\\/]run-homes[\\/]/.test(process.env.PANTHEON_HOME ?? "");
+            if (inRun && argv[1] && !argv[1].startsWith("--"))
+                die("a woken run cannot trust a key — a person has to, on this machine");
+            const cfg = need();
+            const { loadPins, trustPending, updatePins } = await import("./pins.js");
+            const { fingerprint } = await import("./identity.js");
+            const c = new PantheonClient(cfg, undefined, { role: "cli" });
+            await Promise.race([c.connect().catch(() => { }), new Promise((r) => setTimeout(r, 5000))]);
+            const team = c.pinKey();
+            c.close();
+            const p = loadPins();
+            const t = p.teams[team];
+            const who = argv[1] && !argv[1].startsWith("--") ? argv[1] : null;
+            if (!who) {
+                console.log(`${B("Teammates' keys this machine checks messages against")} ${D(`(${cfg.space}; messages ${t?.sigs ? "are" : "are not yet"} signed on this team's relay)`)}\n`);
+                for (const [m, pin] of Object.entries(t?.members ?? {}).sort()) {
+                    console.log(`  ${m.padEnd(16)} ${pin.fp}${m === cfg.member ? D("  (you)") : ""}${pin.pending ? `\n  ${" ".repeat(16)} ${B("changed to")} ${pin.pending.fp} ${D(`— not trusted until you check it with ${m}: pantheon trust ${m}`)}` : ""}`);
+                }
+                if (!t || !Object.keys(t.members).length)
+                    console.log(D("  none yet — keys are pinned the first time this machine sees each teammate"));
+                console.log(D(`\n  Your own key: ${fingerprint(cfg.publicKey)} — read it to a teammate who asks you to confirm it.`));
+                return;
+            }
+            const cur = t?.members[who];
+            if (!cur)
+                die(`no key for "${who}" is known on this machine in "${cfg.space}"`);
+            if (!cur.pending) {
+                console.log(`${C(who)}'s key is ${cur.fp} — nothing is waiting to be confirmed.`);
+                return;
+            }
+            console.log(`${B(`${who}'s key changed`)} (a new machine, or someone else):`);
+            console.log(`  was  ${cur.fp}`);
+            console.log(`  now  ${cur.pending.fp}`);
+            console.log(D(`  Ask ${who} to read theirs out (pantheon trust, last line) and compare. Only then trust it.`));
+            let go = argv.includes("--yes");
+            if (!go && process.stdin.isTTY) {
+                const rl = createInterface({ input: process.stdin, output: process.stderr });
+                const a = ((await questionOrNull(rl, `Trust ${who}'s new key ${cur.pending.fp}? [y/N] `)) ?? "").trim().toLowerCase();
+                rl.close();
+                go = a === "y" || a === "yes";
+            }
+            if (!go) {
+                console.log(D(process.stdin.isTTY ? "  nothing changed" : `  nothing changed — after checking it with ${who}: pantheon trust ${who} --yes`));
+                return;
+            }
+            let outcome = "ok";
+            updatePins((fresh) => {
+                if (fresh.corrupt) {
+                    outcome = "corrupt";
+                    return false;
+                }
+                if (fresh.teams[team]?.members[who]?.pending?.fp !== cur.pending.fp) {
+                    outcome = "moved";
+                    return false;
+                }
+                return !!trustPending(fresh, team, who);
+            });
+            if (outcome === "corrupt")
+                die("keys.json could not be read, so nothing was changed — fix or remove it (pantheon doctor)");
+            if (outcome === "moved")
+                die(`${who}'s held-back key changed while you were deciding — run pantheon trust ${who} again`);
+            console.log(`${C("trusted")} ${who}'s new key on this machine — their signed messages count again.`);
+            return;
+        }
+        case "wake": {
+            const { loadPolicy, setLocalWaker } = await import("./worker-policy.js");
+            const { wakeMode } = await import("./profile.js");
+            const sub = argv[1] ?? "list";
+            const one = () => {
+                if (!flag("space"))
+                    return need();
+                const f = loadAll();
+                const m = f && findMembership(f, flag("space"));
+                if (!f || !m)
+                    die(`you are not in a team called "${flag("space")}"`);
+                return configFor(f, m, null);
+            };
+            if (sub === "allow" || sub === "deny") {
+                const who = argv[2] && !argv[2].startsWith("--") ? argv[2] : die(`usage: pantheon wake ${sub} <name> [--space <team>]`);
+                const cfg = one();
+                if (who === cfg.member)
+                    die("your own requests always reach your own worker; there is nothing to allow");
+                let unchecked = false;
+                let teamBlocks = false;
+                if (sub === "allow") {
+                    const c = new PantheonClient(cfg, undefined, { role: "cli" });
+                    const got = await Promise.race([c.connect().then(() => true, () => false), new Promise((r) => setTimeout(() => r(false), 3_000))]);
+                    if (got) {
+                        const names = c.members.map((m) => m.member);
+                        {
+                            const e = c.members.find((m) => m.member === who);
+                            teamBlocks = e?.admitted === true && !e.revoked_by && e.may_wake === false;
+                        }
+                        c.close();
+                        if (!names.includes(who))
+                            die(`"${who}" is not in "${cfg.space}". Its members: ${names.filter((n) => n !== cfg.member).join(", ") || "only you"}`);
+                    }
+                    else {
+                        try {
+                            c.close();
+                        }
+                        catch { }
+                        unchecked = true;
+                    }
+                }
+                const r = setLocalWaker([cfg.spaceId, cfg.space], who, sub === "allow");
+                if (!r.ok)
+                    die(r.why);
+                const mode = wakeMode(loadProfile(cfg));
+                console.log(sub === "allow"
+                    ? `${C(who)} may wake this machine in ${cfg.space}${r.changed ? "" : D(" (already could)")}`
+                    : `${C(who)} can no longer wake this machine in ${cfg.space}${r.changed ? "" : D(" (could not before either)")}`);
+                console.log(D(`  Recorded on this machine only — nothing was sent to the team. Undo: pantheon wake ${sub === "allow" ? "deny" : "allow"} ${who}${flag("space") ? ` --space ${cfg.space}` : ""}`));
+                if (unchecked)
+                    console.log(D(`  The relay did not answer, so "${who}" was not checked against the team's members — check the spelling (pantheon team).`));
+                if (sub === "allow") {
+                    if (mode === "anyone")
+                        console.log(D(`  This machine is set to wake for anyone the team lets, so the list is used only if you choose "approved" (pantheon setup).`));
+                    if (mode === "no")
+                        console.log(D(`  This machine is set not to be woken at all; the list applies once you choose "approved" (pantheon setup).`));
+                    if (teamBlocks) {
+                        const { markTeamFlagOnYes } = await import("./worker-policy.js");
+                        markTeamFlagOnYes(cfg.spaceId ?? cfg.space, who);
+                    }
+                    if (teamBlocks)
+                        console.log(`  ${B("The team does not let")} ${C(who)} ${B("wake workers yet.")} ${D(`Your worker turns that on the first time ${who}'s request needs this machine (it is said when it does); or now: pantheon admit ${who} --may-wake${teamFlag(cfg)}`)}`);
+                    else if (unchecked)
+                        console.log(D(`  The team must also let ${who} wake workers at all. If their requests are refused with NOT_ALLOWED_TO_WAKE, a member runs: pantheon admit ${who} --may-wake${teamFlag(cfg)}`));
+                }
+                return;
+            }
+            if (sub === "list") {
+                const pol = loadPolicy();
+                const f = loadAll();
+                const teams = flag("space") ? [one()] : f && Object.keys(f.spaces ?? {}).length ? Object.values(f.spaces ?? {}).map((m) => configFor(f, m, null)) : [need()];
+                console.log(`${B("Who may wake this machine")} ${D("(this machine's own list — pantheon wake allow|deny <name>)")}\n`);
+                for (const t of teams) {
+                    const names = [...new Set([...(t.spaceId ? pol.wakers?.[t.spaceId] ?? [] : []), ...(pol.wakers?.[t.space] ?? [])])].sort();
+                    const key = t.spaceId ?? t.space;
+                    const carried = !!(pol.wakersCarried?.[key] || pol.wakersCarried?.[t.space]);
+                    const deferred = !!(pol.wakersDeferred?.[key] || pol.wakersDeferred?.[t.space]);
+                    const mem = Object.values(f?.spaces ?? {}).find((m) => m.id === t.spaceId || m.name === t.space);
+                    const pending = !carried && (deferred || (!!mem && !mem.since));
+                    const why = deferred
+                        ? "when the worker last checked, the team's relay was older than 0.30 — until it is upgraded and the worker reconnects, the team's may_wake decides"
+                        : "from before 0.30 and not carried over yet — the worker does that when it next connects to a 0.30 relay; until then the team's may_wake decides";
+                    console.log(`  ${t.space.padEnd(16)} ${names.length ? names.join(", ") : D("nobody")}${pending ? D(`   (${why})`) : ""}`);
+                }
+                const mode = wakeMode(loadProfile(teams[0]));
+                console.log(`\n  ${D("setting")}          ${mode === "approved" ? "only the people listed above" : mode === "anyone" ? "anyone the team lets wake workers (the list is kept for if you choose \"approved\")" : "nobody — this machine is set not to be woken"}${D("   (pantheon setup to change)")}`);
+                return;
+            }
+            {
+                const near = ["allow", "deny", "list"].map((k) => ({ k, d: slipDistance(sub, k) })).sort((x, y) => x.d - y.d)[0];
+                die(`${near.d <= 2 ? `"${sub}" — did you mean: pantheon wake ${near.k}?\n` : ""}usage: pantheon wake allow <name> [--space <team>] · pantheon wake deny <name> [--space <team>] · pantheon wake list`);
+            }
+        }
         case "policy": {
-            const { loadPolicy, savePolicy, grant, revoke } = await import("./worker-policy.js");
+            const { loadPolicy, savePolicy, grant, revoke, inWokenRun, CAPABILITY_ARGS } = await import("./worker-policy.js");
+            const { COMMAND_GRANT_SCOPE } = await import("./agents.js");
             const sub = argv[1];
             const capArg = (argv[2] ?? "").replace(/-/g, "_");
+            const caps = Object.keys(CAPABILITY_ARGS);
             if (sub === "grant" || sub === "revoke") {
-                if (capArg !== "self_upgrade")
-                    die(`unknown capability "${argv[2] ?? ""}" — capabilities: self-upgrade`);
+                const cap = caps.find((c) => c === capArg) ?? die(`unknown capability "${argv[2] ?? ""}" — capabilities: ${caps.map((c) => CAPABILITY_ARGS[c]).join(", ")}`);
+                if (sub === "grant" && inWokenRun())
+                    die("a woken run cannot grant this machine anything — a person has to run this here");
                 const p = loadPolicy();
-                if (sub === "grant") {
-                    grant(p, "self_upgrade", "always", "policy-command");
-                }
+                if (sub === "grant")
+                    grant(p, cap, "always", "policy-command");
                 else
-                    revoke(p, "self_upgrade");
+                    revoke(p, cap);
                 savePolicy(p);
-                console.log(`${C(sub === "grant" ? "granted" : "revoked")} self-upgrade ${D(sub === "grant" ? "— the worker keeps pantheon current with the relay" : "— the worker will ask in your approvals inbox when it falls behind")}`);
+                const said = cap === "self_upgrade"
+                    ? (sub === "grant" ? "— the worker keeps pantheon current with the relay" : "— the worker will ask in your approvals inbox when it falls behind")
+                    : cap === "unsandboxed_runs"
+                        ? (sub === "grant"
+                            ? "— Codex, Cursor and Copilot answer teammates' requests while you're away, so nobody waits on you. To have them wait for you instead: pantheon policy revoke unsandboxed-runs"
+                            : "— Codex, Cursor and Copilot leave teammates' requests for you to pick up when you're back; Claude Code still answers them. On again: pantheon policy grant unsandboxed-runs")
+                        : (sub === "grant" ? `— ${COMMAND_GRANT_SCOPE}` : "— woken runs are back to edits only");
+                console.log(`${C(sub === "grant" ? "granted" : "revoked")} ${CAPABILITY_ARGS[cap]} ${D(said)}`);
                 return;
             }
             if (sub && sub !== "show")
-                die("usage: pantheon policy [show | grant self-upgrade | revoke self-upgrade]");
+                die(`usage: pantheon policy [show | grant <capability> | revoke <capability>]   capabilities: ${caps.map((c) => CAPABILITY_ARGS[c]).join(", ")}`);
             const p = loadPolicy();
             const w = workerProc();
             console.log(`${B("What this machine's worker may do")}\n`);
             console.log(`  worker         ${w.running ? C("running") : D("not running")}`);
             const su = p.grants.self_upgrade;
             console.log(`  self-upgrade   ${su ? C(su.mode === "always" ? "granted" : "granted once") : D("not granted")}${su ? D(`   (${su.by}, ${new Date(su.at).toLocaleDateString()})`) : D("   — it will ask in your approvals inbox when behind the relay")}`);
-            const openAsk = p.asks.self_upgrade;
-            if (openAsk)
-                console.log(`  ${"\x1b[33mopen request\x1b[0m"}   self-upgrade — answer it: pantheon approvals`);
+            const rc = p.grants.run_commands;
+            const { commandState, repoCommandsAtBase } = await import("./command-state.js");
+            const cs = commandState({ project: resolve(".") });
+            const { commandCaveat } = await import("./command-state.js");
+            const caveat = cs.level !== "off" ? commandCaveat() : "";
+            console.log(`  run-commands   ${rc ? C(rc.mode === "always" ? "granted" : "granted once") : D("not granted")}${rc ? D(`   (${rc.by}, ${new Date(rc.at).toLocaleDateString()})`) : cs.allowBash ? D("   — not needed: the worker runs with --allow-bash") : D("   — woken runs edit files only; it asks when a run needed more")}`);
+            const ur = p.grants.unsandboxed_runs;
+            const { unsandboxedAllowed } = await import("./worker-policy.js");
+            console.log(`  unsandboxed    ${unsandboxedAllowed(p)
+                ? C("on") + D(`   (${ur ? `${ur.by}, ${new Date(ur.at).toLocaleDateString()}` : "the default"}) — Codex, Cursor and Copilot answer teammates while you're away (off: pantheon policy revoke unsandboxed-runs)`)
+                : D("off (your choice) — Codex, Cursor and Copilot leave requests for when you're back; Claude Code still answers them (on: pantheon policy grant unsandboxed-runs)")}`);
+            for (const cap of caps)
+                if (p.asks[cap])
+                    console.log(`  ${"\x1b[33mopen request\x1b[0m"}   ${CAPABILITY_ARGS[cap]} — answer it here: pantheon approvals, or pantheon policy grant ${CAPABILITY_ARGS[cap]}`);
             const pers = loadPersonas(resolve("."), undefined);
-            console.log(`  personas       ${pers.length ? pers.map((x) => x.name).join(", ") + D("   (restricted mode — tighten-only)") : D("none — open mode; peers with may-wake can hand it any matched work")}`);
-            console.log(`  bash           ${D("gated — only a worker started with --allow-bash runs shell, and that flag always prompts")}`);
+            console.log(`  personas       ${pers.length ? pers.map((x) => x.name).join(", ") + D("   (restricted mode — tighten-only)") : D("none — open mode; peers this machine approved to wake it can hand it any matched work")}`);
+            console.log(`  commands       ${cs.level === "off" ? D(cs.summary) : C(cs.summary)}${caveat ? `\n                 \x1b[33m${caveat}\x1b[0m` : ""}`);
+            if (cs.level !== "off")
+                console.log(`                 ${D(COMMAND_GRANT_SCOPE)}`);
+            {
+                const { REPO_COMMANDS_FILE } = await import("./agents.js");
+                const root = repoInfo(process.cwd())?.root;
+                const rc2 = root ? repoCommandsAtBase(root) : { ref: null, ok: [], refused: [] };
+                const at = rc2.ref ? D(` (as committed on ${rc2.ref})`) : "";
+                console.log(`  this repo      ${root ? (rc2.ok.length ? `also allows ${rc2.ok.join(", ")}${at}` : D(`adds no commands${rc2.ref ? ` on ${rc2.ref}` : ""} — list extra ones, one per line, in ${REPO_COMMANDS_FILE} and commit it`)) : D("not in a git repo")}`);
+                for (const r of rc2.refused)
+                    console.log(`                 ${D(`ignored "${r.line}" — ${r.why}`)}`);
+            }
             console.log(`  runs           ${D("12/hour, 40/day, one at a time, 2 failed attempts then parked (defaults; personas only lower them)")}`);
-            console.log(`\n${D("Change it: pantheon policy grant|revoke self-upgrade · personas: pantheon persona init · peers: pantheon admit <who> --may-wake/--revoke")}`);
+            console.log(`\n${D("Change it: pantheon policy grant|revoke self-upgrade|run-commands|unsandboxed-runs · personas: pantheon persona init · who may wake this machine: pantheon wake allow|deny <who>")}`);
             return;
         }
         case "explain": {
@@ -2448,13 +3303,36 @@ async function main() {
             const CONFIG_DIR = dirname(CONFIG_PATH);
             let hud = null;
             if (argv.includes("--queued")) {
+                const refuse = (why) => { console.log(`not sent: ${why}`); process.exit(1); };
+                if (inWokenRun())
+                    refuse("a woken run cannot act for the menu bar — a person has to click it");
                 const f = join(CONFIG_DIR, "bin", ".hud-action.json");
+                const { statSync } = await import("node:fs");
+                let st = null;
+                let raw = null;
                 try {
-                    hud = JSON.parse(readFileSync(f, "utf8"));
+                    st = statSync(f);
+                    raw = readFileSync(f, "utf8");
                     rmSync(f, { force: true });
                 }
                 catch {
-                    hud = null;
+                    st = null;
+                    raw = null;
+                }
+                if (st && raw !== null) {
+                    const age = Date.now() - st.mtimeMs;
+                    const { runInFlight } = await import("./worker.js");
+                    const run = runInFlight(CONFIG_DIR);
+                    if (age > HUD_ACTION_MAX_AGE_MS)
+                        refuse(`that menu-bar action was written ${Math.round(age / 1000)}s ago — click it again`);
+                    if (run && st.mtimeMs >= run.at - 1_000)
+                        refuse("that menu-bar action was written while a woken run was working on this machine, so it is not trusted — click it again once the run is done");
+                    try {
+                        hud = JSON.parse(raw);
+                    }
+                    catch {
+                        hud = null;
+                    }
                 }
             }
             const cfg = (() => {
@@ -2506,7 +3384,7 @@ async function main() {
                     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();
+                    const answer = ((await questionOrNull(rl, `\n${D("run these here now? [y/N] ")}`)) ?? "").toLowerCase();
                     if (answer !== "y" && answer !== "yes") {
                         console.error(D("left for you — the commands are above"));
                         return;
@@ -2565,6 +3443,12 @@ async function main() {
                     .catch((e) => notSent(e.message));
                 c2.close();
                 console.log(`sent ${kind} id=${sent.id} seq=${sent.seq}`);
+                if (kind === "ANSWER") {
+                    const { applyLocalAnswer, describeLocalAnswer } = await import("./worker-policy.js");
+                    const g = applyLocalAnswer(ref, body);
+                    if (g)
+                        console.error(describeLocalAnswer(g));
+                }
                 return;
             }
             if (hud?.action === "retract") {
@@ -2633,7 +3517,7 @@ async function main() {
                 const agent = pickExplainAgent(hud.tool ?? p0.agent.primary_surface, detectAvailable());
                 const goalId = a?.goal ?? o?.goal ?? null;
                 const rl = createInterface({ input: process.stdin, output: process.stderr });
-                const ask = (q) => new Promise((res) => rl.question(q, (v) => res(v.trim())));
+                const ask = async (q) => (await questionOrNull(rl, q)) ?? "";
                 try {
                     for (;;) {
                         console.error(`\n${B("Next")}${agent ? `  ${C("1")} open in ${agent.id} with this loaded` : ""}  ${C("2")} reply from here${goalId ? `  ${C("3")} show the whole thread` : ""}  ${D("Enter) close")}`);
@@ -2675,6 +3559,12 @@ async function main() {
                                 await c3.connect();
                                 const sent = await c3.send({ act: kind, body: text, goal: o ? null : goalId, ref, to });
                                 console.error(`  ${C("sent")} ${kind} id=${sent.id}`);
+                                if (kind === "ANSWER") {
+                                    const { applyLocalAnswer, describeLocalAnswer } = await import("./worker-policy.js");
+                                    const g = applyLocalAnswer(ref, text);
+                                    if (g)
+                                        console.error(`  ${describeLocalAnswer(g)}`);
+                                }
                             }
                             catch (e) {
                                 console.error(`  ${e.message}`);
@@ -2777,6 +3667,10 @@ async function main() {
                 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}`);
+                const { applyLocalAnswer, describeLocalAnswer } = await import("./worker-policy.js");
+                const g = applyLocalAnswer(hit.o.ref, answer);
+                if (g)
+                    console.log(`  ${describeLocalAnswer(g)}`);
                 closeAll();
                 return;
             }
@@ -2785,10 +3679,21 @@ async function main() {
                     die("usage: pantheon approvals show <obligation-id>");
                 const hit = find(id) ?? die(`no decision ${id} is waiting on you`);
                 console.log(`${B("Decision required")}  ${hit.o.id}${conns.length > 1 ? `  ${D("in " + hit.cfg.space)}` : ""}`);
+                const full = hit.client.seenAct(hit.o.ref) ?? (await fetchAct(hit.cfg, hit.o.ref, 4000).catch(() => null))?.act;
                 console.log(`  ${hit.o.body}`);
+                if (full?.body && full.body.trim() !== hit.o.body.trim())
+                    console.log(`\n${full.body.split("\n").map((l) => `  ${l}`).join("\n")}`);
                 if (hit.o.goal)
                     console.log(`  goal  ${hit.client.goals.get(hit.o.goal)?.title ?? hit.o.goal}`);
-                console.log(`\nAnswer: ${C(`pantheon approvals answer ${hit.o.id} 'your decision and rationale'`)}`);
+                const { localChoices } = await import("./tray.js");
+                const choices = localChoices(hit.o.ref);
+                if (choices) {
+                    console.log(`\nAnswer on this machine, one of:`);
+                    for (const c of choices)
+                        console.log(`  ${c.label.padEnd(16)} ${C(`pantheon approvals answer ${hit.o.id} ${c.answer}`)}`);
+                }
+                else
+                    console.log(`\nAnswer: ${C(`pantheon approvals answer ${hit.o.id} 'your decision and rationale'`)}`);
                 closeAll();
                 return;
             }
@@ -2796,8 +3701,11 @@ async function main() {
                 die("usage: pantheon approvals [list | show <id> | answer <id> <decision>]");
             if (!all.length)
                 console.log(D(conns.length > 1 ? `no decisions waiting on you in any of your ${conns.length} teams` : "no decisions waiting on you"));
-            for (const { o, cfg, client } of all)
-                console.log(`${C(o.id)}  ${conns.length > 1 ? D(`[${cfg.space}] `) : ""}${client.goals.get(o.goal ?? "")?.title ?? "No goal"}\n  ${o.body}`);
+            const { localChoices: lc } = await import("./tray.js");
+            for (const { o, cfg, client } of all) {
+                const ch = lc(o.ref);
+                console.log(`${C(o.id)}  ${conns.length > 1 ? D(`[${cfg.space}] `) : ""}${client.goals.get(o.goal ?? "")?.title ?? (ch ? "This machine" : "No goal")}\n  ${o.body}${ch ? D(`\n  answer: ${ch.map((c) => c.answer).join(" / ")}   (pantheon approvals show ${o.id})`) : ""}`);
+            }
             closeAll();
             return;
         }
@@ -2840,12 +3748,13 @@ async function main() {
             return;
         }
         case "worker": {
+            (await import("./machine.js")).recordWorkerPid();
             const allCfg = loadAll();
             const bindings = Object.values(allCfg?.bindings ?? {});
             if (!flag("project") && bindings.length) {
                 const { WorkerFleet } = await import("./worker-fleet.js");
                 const fleet = new WorkerFleet({
-                    ...(flag("agent-cmd") ? { agentCmd: flag("agent-cmd") } : { agent: flag("agent", "auto") }),
+                    ...(flag("agent-cmd") ? { agentCmd: flag("agent-cmd"), agentCmdFromCli: true } : { agent: flag("agent", "auto") }),
                     ...(flag("persona") ? { persona: flag("persona") } : {}),
                     continuations: !argv.includes("--no-continue"),
                     allowBash: argv.includes("--allow-bash"),
@@ -2862,10 +3771,10 @@ async function main() {
                     }),
                     log: (l) => console.error(l),
                 });
-                console.error(`${B("pantheon worker")} ${D(`(${bindings.length} bound repo${bindings.length === 1 ? "" : "s"} · ctrl-c to stop)`)}`);
+                console.error(`${B("pantheon worker")} ${D(`(${bindings.length} bound folder${bindings.length === 1 ? "" : "s"} · ctrl-c to stop)`)}`);
                 if (argv.includes("--allow-bash")) {
                     console.error(`\x1b[33m  --allow-bash: a woken run may execute commands. Only do this if you trust every\x1b[0m`);
-                    console.error(`\x1b[33m  peer you granted --may-wake, since their request is what starts the run.\x1b[0m`);
+                    console.error(`\x1b[33m  teammate approved to wake this machine (pantheon wake list), since their request is what starts the run.\x1b[0m`);
                 }
                 process.on("SIGINT", () => { fleet.stop(); process.exit(0); });
                 await fleet.run();
@@ -2876,7 +3785,7 @@ async function main() {
             const worker = new Worker(cfg, {
                 project,
                 scratch: resolve(flag("scratch", join(project, ".pantheon", "worktrees"))),
-                ...(flag("agent-cmd") ? { agentCmd: flag("agent-cmd") } : { agent: flag("agent", "auto") }),
+                ...(flag("agent-cmd") ? { agentCmd: flag("agent-cmd"), agentCmdFromCli: true } : { agent: flag("agent", "auto") }),
                 ...(flag("persona") ? { persona: flag("persona") } : {}),
                 continuations: !argv.includes("--no-continue"),
                 allowBash: argv.includes("--allow-bash"),
@@ -2896,7 +3805,7 @@ async function main() {
             console.error(`${B("pantheon worker")} ${D("(ctrl-c to stop)")}`);
             if (argv.includes("--allow-bash")) {
                 console.error(`\x1b[33m  --allow-bash: a woken run may execute commands. Only do this if you trust every\x1b[0m`);
-                console.error(`\x1b[33m  peer you granted --may-wake, since their request is what starts the run.\x1b[0m`);
+                console.error(`\x1b[33m  teammate approved to wake this machine (pantheon wake list), since their request is what starts the run.\x1b[0m`);
             }
             process.on("SIGINT", () => { worker.stop(); process.exit(0); });
             await worker.run();
@@ -3044,12 +3953,12 @@ async function main() {
                 }
                 for (const l of installService(kind, homedir(), extraN))
                     console.error(l);
-                console.error(`\n${D("Clicking an alert opens the primary surface in `pantheon profile`. No agent run or --may-wake permission is involved.")}`);
+                console.error(`\n${D("Clicking an alert opens the primary surface in `pantheon profile`. No agent run or wake permission is involved.")}`);
                 return;
             }
             need();
             const project = resolve(flag("project", "."));
-            const extra = ["--project", project];
+            const extra = flag("project") ? ["--project", project] : [];
             if (argv.includes("--allow-bash"))
                 extra.push("--allow-bash");
             if (argv.includes("--no-continue"))
@@ -3059,10 +3968,10 @@ async function main() {
                     extra.push(`--${f}`, flag(f));
             }
             console.error(`${B("installing the pantheon worker as a background service")}`);
-            console.error(D(`  project ${project}`));
+            console.error(D(flag("project") ? `  project ${project} (this checkout only)` : `  serves   every repo and folder bound to a team on this machine`));
             for (const l of installService(kind, project, extra))
                 console.error(l);
-            console.error(`\n${D("It only acts on requests from peers you granted --may-wake, one run at a time.")}`);
+            console.error(`\n${D("It only acts on requests from teammates approved on this machine — you are asked the first time each one needs it — one run at a time.")}`);
             return;
         }
         case "spaces": {
@@ -3079,9 +3988,13 @@ async function main() {
                 const tags = [m.id === all.default_space ? C("default") : "", here.cfg?.spaceId === m.id || (here.cfg?.space === m.name && here.reason !== "none") ? C("← here") : ""].filter(Boolean).join("  ");
                 console.error(`  ${B(m.name.padEnd(18))} ${D(new URL(m.relay).host)}  ${tags}`);
                 for (const b of bound)
-                    console.error(`      ${D("repo")}  ${b.origin ?? b.path}${b.origin ? D(`  (${b.path})`) : ""}`);
+                    console.error(`      ${D(b.origin === null && !existsSync(join(b.path, ".git")) ? "folder" : "repo")}  ${b.origin ?? b.path}${b.origin ? D(`  (${b.path})`) : ""}`);
                 if (!bound.length)
                     console.error(`      ${D("repo  none bound — run `pantheon use " + m.name + " --here` from its checkout")}`);
+                const boundFps = new Set(Object.entries(all.bindings ?? {}).filter(([, b]) => b.space === m.id).map(([k]) => k));
+                const missing = (m.repos ?? []).filter((r) => !boundFps.has(r.fp)).map((r) => r.name);
+                if (missing.length)
+                    console.error(`      ${D(`not on this machine: ${missing.join(", ")} — pantheon repo find, once you have ${missing.length === 1 ? "it" : "them"} cloned`)}`);
             }
             const r = repoInfo(process.cwd());
             console.error(`\n  ${D("this folder:")} ${r ? (r.origin ?? r.root) : D("not a git repo")} ${D("→")} ${here.reason === "binding" ? `"${here.cfg.space}"` : here.reason === "single" ? `"${here.cfg.space}" (your only team)` : here.reason === "default" ? `unbound — humans get the default "${here.cfg.space}"; agents refuse` : here.reason === "stale" ? "bound to a team you have left" : "unbound"}`);
@@ -3089,10 +4002,53 @@ async function main() {
         }
         case "use": {
             const all = loadAll() ?? die("not configured. Run `pantheon signup` first.");
-            const ref = argv[1] ?? die("usage: pantheon use <team> [--here]      # --here binds this repo to the team; without it, sets your default");
+            if (argv.includes("--unbind")) {
+                const { folderBinding } = await import("./config.js");
+                const r = repoInfo(process.cwd());
+                const fb = r ? null : folderBinding(all, process.cwd());
+                const key = r ? r.fingerprint : fb && fb.path === realpathSync.native(process.cwd()) ? fb.key : null;
+                if (fb && !key)
+                    die(`this folder is not bound itself — ${fb.path} is, and this folder is inside it. Run pantheon use --unbind there.`);
+                const was = key ? all.bindings?.[key] : undefined;
+                if (!key || !was || !unbindRepo(key))
+                    die(`${r ? "this repo" : "this folder"} is not bound to a team — nothing to undo`);
+                console.error(`${B("unbound")} ${r ? (r.origin ?? r.root) : was.path} — it was "${findMembership(all, was.space)?.name ?? was.space}"; it now resolves as a folder bound to no team`);
+                return;
+            }
+            const ref = argv[1] && !argv[1].startsWith("--") ? argv[1] : die("usage: pantheon use <team> [--here]      # --here binds this repo to the team; without it, sets your default");
             const m = findMembership(all, ref) ?? die(`you are not in a team called "${ref}". Yours: ${Object.values(all.spaces ?? {}).map((x) => x.name).join(", ") || "none"}`);
             if (argv.includes("--here")) {
-                const r = repoInfo(process.cwd()) ?? die("this folder is not inside a git repo. Run it from the team's checkout.");
+                const r = repoInfo(process.cwd());
+                if (!r) {
+                    for (let d = resolve(process.cwd());; d = dirname(d)) {
+                        if (existsSync(join(d, ".git")))
+                            die(`this folder is inside a git repo (${d}), but git did not answer — check that git works here (git status), then run this again.`);
+                        if (dirname(d) === d)
+                            break;
+                    }
+                    const real = (d) => { try {
+                        return realpathSync.native(d);
+                    }
+                    catch {
+                        return resolve(d);
+                    } };
+                    const here = real(process.cwd());
+                    if ((here === real(homedir()) || dirname(here) === here) && !argv.includes("--yes")) {
+                        die(`this is ${dirname(here) === here ? "the root of the disk" : "your home folder"}: binding it puts every folder under it in "${m.name}", and an agent opened anywhere there would speak for that team.\n  Bind a project folder instead, or if you mean it:  pantheon use ${m.name} --here --yes`);
+                    }
+                    if ((await import("./repo-find.js")).holdsRepo(process.cwd())) {
+                        const n = await bindReposIn(process.cwd(), all, m, argv.includes("--yes"), `pantheon use ${m.name} --here --yes`);
+                        if (!n)
+                            console.error(D(`  nothing bound — the folder itself is not bound, since it holds repos`));
+                        else
+                            console.error(D(`  Agents opened in those repos now speak as you in "${m.name}". Restart any that are open.`));
+                        return;
+                    }
+                    const { replaced } = bindFolder(process.cwd(), m.id);
+                    console.error(`${B("bound")} this folder → "${m.name}"${replaced ? D(`  (was: ${findMembership(all, replaced.space)?.name ?? replaced.space})`) : ""}`);
+                    console.error(D(`  Agents opened here, or in any folder below, now speak as you in "${m.name}". Restart any that are open.`));
+                    return;
+                }
                 const { replaced } = bindRepo(r, m.id);
                 console.error(`${B("bound")} ${r.origin ?? r.root} → "${m.name}"${replaced ? D(`  (was: ${findMembership(all, replaced.space)?.name ?? replaced.space})`) : ""}`);
                 if (!r.shared)
@@ -3119,6 +4075,15 @@ async function main() {
             const { repo: _r, repoOrigin: _o, ...plain } = cfg;
             const client = new PantheonClient(plain, undefined, { role: "cli" });
             await client.connect().catch((e) => die(client.pending ?? connectFailure(e, plain.relay)));
+            if (sub === "find") {
+                await new Promise((res) => setTimeout(res, 150));
+                const all = loadAll() ?? die("not configured");
+                const m = findMembership(all, cfg.spaceId ?? cfg.space) ?? findMembership(all, cfg.space) ?? die(`not in "${cfg.space}" on this machine`);
+                const where = argv[2] && !argv[2].startsWith("--") ? resolve(argv[2]) : null;
+                client.close();
+                await findAndBindRepos(all, m, client.repos, { ...(where ? { extra: [where] } : {}), recents: argv.includes("--recents") ? true : undefined, yes: argv.includes("--yes") });
+                return;
+            }
             if (sub === "add") {
                 const r = repoInfo(flag("path") ?? process.cwd()) ?? die("not inside a git repo");
                 const base = flag("base") ?? null;
@@ -3154,12 +4119,26 @@ async function main() {
         case "version":
             console.log(VERSION);
             return;
-        case "help":
-            console.error(argv.includes("--all") || argv[1] === "all" ? HELP_ALL : HELP);
+        case "help": {
+            const topic = argv[1] && argv[1] !== "all" && !argv[1].startsWith("-") ? argv[1] : null;
+            if (topic && (usageFor(topic, HELP_ALL) || COMMAND_FLAGS[topic])) {
+                console.log(`${usageFor(topic, HELP_ALL) ?? `  pantheon ${topic}`}${COMMAND_FLAGS[topic] ? `\n\n${B("flags")}\n  ${COMMAND_FLAGS[topic]}` : ""}`);
+                return;
+            }
+            console.log(argv.includes("--all") || argv[1] === "all" ? HELP_ALL : HELP);
+            return;
+        }
+        case "--help":
+        case "-h":
+            console.log(argv.includes("--all") ? HELP_ALL : HELP);
             return;
-        default:
-            console.error(argv.includes("--all") ? HELP_ALL : HELP);
-            process.exit(cmd === "help" || cmd === "--help" ? 0 : 1);
+        default: {
+            const known = [...new Set([...HELP_ALL.matchAll(/pantheon ([a-z][a-z-]*)/g)].map((m) => m[1]))];
+            const near = known.map((k) => ({ k, d: slipDistance(cmd, k) })).sort((x, y) => x.d - y.d)[0];
+            console.error(`unknown command "${cmd}"${near && near.d <= 2 ? ` — did you mean: pantheon ${near.k}?` : ""}`);
+            console.error(D("all commands: pantheon help   ·   everything: pantheon help --all"));
+            process.exit(1);
+        }
     }
 }
 main().catch((e) => die(describeNetError(e, (() => { try {