@join-pantheon/cli 0.33.1 → 0.33.2

package/dist/folder-snapshot.js

@@ -0,0 +1,432 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, realpath, rm, rmdir, stat, unlink, utimes, chmod, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { join, resolve, win32 } from "node:path";
+import { SECRET_FILE_GLOBS, SECRET_HOME_PATHS } from "./claude-confine.js";
+export const FOLDER_SNAPSHOT_LIMITS = { files: 5_000, bytes: 200 * 1024 * 1024, dirs: 5_000 };
+export const SNAPSHOT_STALE_MS = 3 * 24 * 60 * 60_000;
+export const SNAPSHOT_LOG_KEEP_MS = 14 * 24 * 60 * 60_000;
+export const DRAFTS_MARKER = ".pantheon-drafts.json";
+const LEFT_OUT_DIRS = new Set([".git", "node_modules"]);
+export function snapshotRoot(scratch, folder) {
+    return join(scratch, `folder-${createHash("sha256").update(resolve(folder)).digest("hex").slice(0, 10)}`);
+}
+const globRe = (g) => new RegExp(`^${g.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`, "i");
+const SECRET_FILES = SECRET_FILE_GLOBS.map(globRe);
+export function isSecretPath(rel, dir) {
+    const low = rel.toLowerCase();
+    const name = low.slice(low.lastIndexOf("/") + 1);
+    if (!dir && SECRET_FILES.some((re) => re.test(name)))
+        return true;
+    return SECRET_HOME_PATHS.some((p) => p.dir === dir && (low === p.rel.toLowerCase() || low.endsWith(`/${p.rel.toLowerCase()}`)));
+}
+const longPath = (p, os) => (os === "win32" ? win32.toNamespacedPath(p) : p);
+export const shown = (s) => s.replace(/\\\\\?\\UNC\\/gi, "\\\\").replace(/\\\\\?\\/g, "");
+const samePath = (a, b, os) => {
+    const n = (p) => shown(p).normalize("NFC");
+    return os === "win32" || os === "darwin" ? n(a).toLowerCase() === n(b).toLowerCase() : n(a) === n(b);
+};
+export async function takeSnapshot(src, dest, o = {}) {
+    const limits = o.limits ?? FOLDER_SNAPSHOT_LIMITS;
+    const os = o.os ?? process.platform;
+    const L = (p) => longPath(p, os);
+    let root;
+    const why = (e) => shown(e.message.split("\n")[0] ?? "");
+    try {
+        root = await realpath(L(src));
+    }
+    catch (e) {
+        return { ok: false, error: `the folder could not be read (${why(e)})` };
+    }
+    root = shown(root);
+    const skipped = { links: [], secrets: [], leftOut: [], other: [] };
+    const dirs = [];
+    const files = [];
+    let bytes = 0;
+    const stack = [""];
+    try {
+        while (stack.length) {
+            const rel = stack.pop();
+            const here = rel ? join(root, ...rel.split("/")) : root;
+            let names;
+            try {
+                names = (await readdir(L(here))).sort();
+            }
+            catch (e) {
+                if (!rel)
+                    throw e;
+                skipped.other.push(rel);
+                dirs.splice(dirs.indexOf(rel), 1);
+                continue;
+            }
+            let again = "";
+            try {
+                again = await realpath(L(here));
+            }
+            catch { }
+            if (!again || !samePath(again, here, os)) {
+                if (!rel)
+                    return { ok: false, error: "the folder moved while it was being copied" };
+                skipped.links.push(rel);
+                dirs.splice(dirs.indexOf(rel), 1);
+                continue;
+            }
+            for (const name of names) {
+                const r = rel ? `${rel}/${name}` : name;
+                const abs = join(here, name);
+                let st;
+                try {
+                    st = await lstat(L(abs));
+                }
+                catch {
+                    skipped.other.push(r);
+                    continue;
+                }
+                if (st.isSymbolicLink()) {
+                    skipped.links.push(r);
+                    continue;
+                }
+                if (st.isDirectory()) {
+                    if (LEFT_OUT_DIRS.has(name.toLowerCase())) {
+                        skipped.leftOut.push(r);
+                        continue;
+                    }
+                    if (isSecretPath(r, true)) {
+                        skipped.secrets.push(r);
+                        continue;
+                    }
+                    let real = "";
+                    try {
+                        real = await realpath(L(abs));
+                    }
+                    catch { }
+                    if (!real || !samePath(real, abs, os)) {
+                        skipped.links.push(r);
+                        continue;
+                    }
+                    if (dirs.length >= limits.dirs)
+                        return { ok: false, tooLarge: { what: "dirs", limit: limits.dirs } };
+                    dirs.push(r);
+                    stack.push(r);
+                    continue;
+                }
+                if (!st.isFile()) {
+                    skipped.other.push(r);
+                    continue;
+                }
+                if (isSecretPath(r, false)) {
+                    skipped.secrets.push(r);
+                    continue;
+                }
+                if (st.nlink > 1) {
+                    skipped.links.push(r);
+                    continue;
+                }
+                if (files.length >= limits.files)
+                    return { ok: false, tooLarge: { what: "files", limit: limits.files } };
+                bytes += st.size;
+                if (bytes > limits.bytes)
+                    return { ok: false, tooLarge: { what: "bytes", limit: limits.bytes } };
+                files.push({ rel: r, size: st.size, ino: st.ino, mode: st.mode });
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, error: `the folder could not be read (${why(e)})` };
+    }
+    const copied = new Map();
+    const budget = { used: 0, limit: limits.bytes, over: false };
+    try {
+        await mkdir(L(dest), { recursive: true, mode: 0o700 });
+        for (const d of dirs)
+            await mkdir(L(join(dest, ...d.split("/"))), { mode: 0o755 });
+        const queue = files.slice();
+        const worker = async () => {
+            for (let f = queue.shift(); f && !budget.over; f = queue.shift()) {
+                const got = await copyOne(join(root, ...f.rel.split("/")), join(dest, ...f.rel.split("/")), f, os, budget);
+                if (got === "changed") {
+                    skipped.other.push(f.rel);
+                    continue;
+                }
+                if (got === "over") {
+                    budget.over = true;
+                    return;
+                }
+                copied.set(f.rel, got);
+            }
+        };
+        const failed = (await Promise.allSettled(Array.from({ length: 8 }, worker))).find((s) => s.status === "rejected");
+        if (failed)
+            throw failed.reason;
+    }
+    catch (e) {
+        await removeSnapshot(dest, os);
+        return { ok: false, error: `the folder could not be copied (${why(e)})` };
+    }
+    if (budget.over) {
+        await removeSnapshot(dest, os);
+        return { ok: false, tooLarge: { what: "bytes", limit: limits.bytes } };
+    }
+    return { ok: true, snap: { dir: dest, src: root, files: copied, bytes: budget.used, skipped } };
+}
+async function copyOne(from, to, want, os, budget) {
+    const flags = constants.O_RDONLY | (os === "win32" ? 0 : (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    let fh;
+    try {
+        fh = await open(longPath(from, os), flags);
+    }
+    catch {
+        return "changed";
+    }
+    try {
+        const st = await fh.stat();
+        if (!st.isFile() || st.nlink > 1 || (want.ino && st.ino && st.ino !== want.ino))
+            return "changed";
+        if (budget.over || budget.used + st.size > budget.limit)
+            return "over";
+        const out = await open(longPath(to, os), "wx", 0o600);
+        let size = 0;
+        try {
+            const buf = Buffer.allocUnsafe(1 << 20);
+            for (;;) {
+                let bytesRead;
+                try {
+                    ({ bytesRead } = await fh.read(buf, 0, buf.length, null));
+                }
+                catch {
+                    budget.used -= size;
+                    size = -1;
+                    break;
+                }
+                if (!bytesRead)
+                    break;
+                if (budget.over || budget.used + bytesRead > budget.limit)
+                    return "over";
+                budget.used += bytesRead;
+                size += bytesRead;
+                await out.write(buf, 0, bytesRead);
+            }
+        }
+        finally {
+            await out.close();
+        }
+        if (size < 0) {
+            try {
+                await unlink(longPath(to, os));
+            }
+            catch { }
+            return "changed";
+        }
+        try {
+            await utimes(longPath(to, os), st.atime, st.mtime);
+        }
+        catch { }
+        if (os !== "win32") {
+            try {
+                await chmod(to, st.mode & 0o777);
+            }
+            catch { }
+        }
+        const after = await stat(longPath(to, os));
+        return { size, mtimeMs: after.mtimeMs };
+    }
+    finally {
+        await fh.close();
+    }
+}
+export async function snapshotDrafts(snap, pantheons, o = {}) {
+    const os = o.os ?? process.platform;
+    let budget = o.max ?? FOLDER_SNAPSHOT_LIMITS.files * 4;
+    const drafts = [];
+    const stack = [""];
+    while (stack.length) {
+        const rel = stack.pop();
+        let names;
+        try {
+            names = (await readdir(longPath(rel ? join(snap.dir, ...rel.split("/")) : snap.dir, os))).sort();
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (--budget < 0)
+                return { drafts, complete: false };
+            const r = rel ? `${rel}/${name}` : name;
+            let st;
+            try {
+                st = await lstat(longPath(join(snap.dir, ...r.split("/")), os));
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                stack.push(r);
+                continue;
+            }
+            if (!st.isFile() || pantheons(r))
+                continue;
+            const was = snap.files.get(r);
+            if (!was || was.size !== st.size || was.mtimeMs !== st.mtimeMs)
+                drafts.push(r);
+        }
+    }
+    return { drafts: drafts.sort(), complete: true };
+}
+export async function keepOnlyDrafts(dir, drafts, meta, os = process.platform) {
+    await writeDraftsMarker(dir, drafts, meta, true, os);
+    const keep = new Set([...drafts, DRAFTS_MARKER]);
+    const walk = async (rel) => {
+        const here = rel ? join(dir, ...rel.split("/")) : dir;
+        let names;
+        try {
+            names = await readdir(longPath(here, os));
+        }
+        catch {
+            return false;
+        }
+        let left = 0;
+        for (const name of names) {
+            const r = rel ? `${rel}/${name}` : name;
+            const abs = longPath(join(here, name), os);
+            let st;
+            try {
+                st = await lstat(abs);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (await walk(r)) {
+                    try {
+                        await rmdir(abs);
+                        continue;
+                    }
+                    catch { }
+                }
+                left++;
+            }
+            else if (keep.has(r))
+                left++;
+            else {
+                try {
+                    await unlink(abs);
+                }
+                catch {
+                    left++;
+                }
+            }
+        }
+        return left === 0;
+    };
+    await walk("");
+}
+async function writeDraftsMarker(dir, drafts, meta, complete, os) {
+    const at = longPath(join(dir, DRAFTS_MARKER), os);
+    await rm(at, { recursive: true, force: true });
+    await writeFile(at, JSON.stringify({ folder: meta.folder, at: meta.at, drafts, ...(complete ? {} : { complete: false }) }, null, 2), { mode: 0o644, flag: "wx" });
+}
+export async function keepDrafts(dir, found, meta, o = {}) {
+    const os = o.os ?? process.platform;
+    const why = (e) => shown(e.message.split("\n")[0] ?? "");
+    try {
+        await writeDraftsMarker(dir, found.drafts, meta, found.complete, os);
+    }
+    catch (e) {
+        return { cut: false, error: `could not mark ${shown(dir)} as drafts (${why(e)}) — the whole copy is kept, but it is not protected from the sweep at the next start` };
+    }
+    if (!found.complete)
+        return { cut: false };
+    try {
+        await (o.cut ?? keepOnlyDrafts)(dir, found.drafts, meta, os);
+        return { cut: true };
+    }
+    catch (e) {
+        try {
+            await lstat(longPath(join(dir, DRAFTS_MARKER), os));
+        }
+        catch {
+            try {
+                await writeDraftsMarker(dir, found.drafts, meta, found.complete, os);
+            }
+            catch { }
+        }
+        return { cut: false, error: `could not clear the unchanged files out of ${shown(dir)} (${why(e)}) — the whole copy is kept` };
+    }
+}
+export async function removeSnapshot(dir, os = process.platform) {
+    try {
+        await rm(longPath(dir, os), { recursive: true, force: true, maxRetries: 3 });
+    }
+    catch { }
+}
+export async function sweepSnapshots(scratch, o = {}) {
+    const now = o.now ?? Date.now();
+    const os = o.os ?? process.platform;
+    const staleMs = o.staleMs ?? SNAPSHOT_STALE_MS, logMs = o.logMs ?? SNAPSHOT_LOG_KEEP_MS;
+    const gone = [];
+    let roots;
+    try {
+        roots = (await readdir(longPath(scratch, os))).filter((n) => n.startsWith("folder-"));
+    }
+    catch {
+        return gone;
+    }
+    for (const r of roots) {
+        const root = join(scratch, r);
+        let st;
+        try {
+            st = await lstat(longPath(root, os));
+        }
+        catch {
+            continue;
+        }
+        if (!st.isDirectory())
+            continue;
+        let names;
+        try {
+            names = await readdir(longPath(root, os));
+        }
+        catch {
+            continue;
+        }
+        let left = names.length;
+        for (const n of names) {
+            const p = join(root, n);
+            let s;
+            try {
+                s = await lstat(longPath(p, os));
+            }
+            catch {
+                continue;
+            }
+            if (s.isDirectory()) {
+                if (now - s.mtimeMs < staleMs)
+                    continue;
+                try {
+                    await lstat(longPath(join(p, DRAFTS_MARKER), os));
+                    continue;
+                }
+                catch { }
+                await removeSnapshot(p, os);
+                gone.push(p);
+                left--;
+            }
+            else if (n.endsWith(".run.log") && now - s.mtimeMs >= logMs) {
+                try {
+                    await unlink(longPath(p, os));
+                    gone.push(p);
+                    left--;
+                }
+                catch { }
+            }
+        }
+        if (left === 0) {
+            try {
+                await rmdir(longPath(root, os));
+            }
+            catch { }
+        }
+    }
+    return gone;
+}
+//# sourceMappingURL=folder-snapshot.js.map

package/dist/install.js

@@ -258,6 +258,20 @@ export function claudeAddFailed(e, command) {
     return `failed: claude mcp add did not work (${why}) — fix: run \`${command}\` yourself to see why, then pantheon install --user`;
 }
 export const CLAUDE_DIRECT_NOTE = "written to ~/.claude.json directly (no claude CLI here) — the Claude desktop app and Claude Code read it";
+export function claudeUserEntryState(file, entry) {
+    let there;
+    try {
+        there = JSON.parse(stripBom(readFileSync(file, "utf8")))?.mcpServers?.["pantheon"];
+    }
+    catch {
+        return "absent";
+    }
+    if (there === undefined)
+        return "absent";
+    if (JSON.stringify(there) === JSON.stringify(claudeUserEntryShape(entry)))
+        return "matches";
+    return isOurMcpEntry(there) ? "other" : "not ours";
+}
 export function claudeUserScope(entry, present = true, claudeBin = which("claude"), home = homedir(), direct = false) {
     const tool = "claude code";
     if (!claudeBin) {
@@ -268,14 +282,7 @@ export function claudeUserScope(entry, present = true, claudeBin = which("claude
         if (conflict)
             return { tool, where: "-", status: `skipped (claude not on PATH) — ${conflict}` };
         if (!direct || inWokenRun()) {
-            const there = (() => { try {
-                const d = JSON.parse(stripBom(readFileSync(file, "utf8")));
-                return d?.mcpServers?.["pantheon"];
-            }
-            catch {
-                return undefined;
-            } })();
-            return there !== undefined && JSON.stringify(there) === JSON.stringify(claudeUserEntryShape(entry))
+            return claudeUserEntryState(file, entry) === "matches"
                 ? { tool, where: file, status: `unchanged — ${CLAUDE_DIRECT_NOTE}` }
                 : { tool, where: "-", status: "skipped (claude not on PATH here) — run pantheon install --user yourself to write ~/.claude.json directly" };
         }

package/dist/machine.js

@@ -5,7 +5,9 @@ import { dirname, join, resolve } from "node:path";
 import { CONFIG_DIR } from "./config.js";
 import { borrowedHome, disableService, existingUnitPath, plistPath, serviceInstalled, serviceLogFile, stopWindowsHost, unitPath, unitPaths, uninstallService } from "./service.js";
 import { LEGACY_TASK_NAME, hostAlive, hostChildRunning, hostFiles, isHostKind, readHostState, recordedTaskName } from "./win-host.js";
-import { copilotMcpConfigFile, vsCodeUserDir, kiroMcpConfigFile, kiroDir } from "./install.js";
+import { copilotMcpConfigFile, vsCodeUserDir, kiroMcpConfigFile, kiroDir, claudeUserEntryState, userEntry } from "./install.js";
+import { claudeJsonFile } from "./claude-config.js";
+import { agentSpawn, which } from "./which.js";
 import { HOME_MARKER, homeEntryFor, isPantheonHomeName, pantheonHomeRefusal, refusedHomeLine } from "./home-safety.js";
 const sh = (cmd) => {
     try {
@@ -364,10 +366,48 @@ export function recordWorkerPid(file = workerPidFile()) {
     }
     catch { }
 }
-export function wiring() {
+const realClaudeWiringDeps = () => ({
+    claudeBin: which("claude"),
+    list: (bin) => {
+        try {
+            const s = agentSpawn(bin, ["mcp", "list"]);
+            return execFileSync(s.command, s.args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 30_000, ...s.options });
+        }
+        catch (e) {
+            const out = e.stdout;
+            return typeof out === "string" && out.trim() ? out : null;
+        }
+    },
+    home: homedir(),
+    entry: () => userEntry(),
+});
+export function claudeWiring(d = realClaudeWiringDeps()) {
+    if (d.claudeBin) {
+        const listed = d.list(d.claudeBin);
+        if (listed !== null) {
+            const line = listed.split(/\r?\n/).find((l) => /^\s*pantheon\b/i.test(l));
+            if (!line)
+                return "not wired";
+            return /✓|✔|\bConnected/i.test(line) && !/fail/i.test(line) ? "wired, connects" : "wired, not connecting";
+        }
+    }
+    let entry = null;
+    try {
+        entry = d.entry();
+    }
+    catch { }
+    const state = claudeUserEntryState(claudeJsonFile(d.home), entry ?? { command: "", args: [] });
+    const where = d.claudeBin ? "in ~/.claude.json" : "in ~/.claude.json, which the Claude app reads (no claude CLI here)";
+    switch (state) {
+        case "matches": return `wired — ${where}`;
+        case "other": return `wired to another pantheon install — ${where}; pantheon install --user points it at this one`;
+        case "not ours": return "not wired — ~/.claude.json has a server called pantheon that Pantheon did not write";
+        default: return "not wired";
+    }
+}
+export function wiring(claude = realClaudeWiringDeps()) {
     const out = [];
-    const claude = sh(`claude mcp list 2>/dev/null | grep -i "^pantheon"`);
-    out.push({ tool: "claude code", state: claude ? (/✔|Connected/i.test(claude) ? "wired, connects" : "wired, not connecting") : "not wired" });
+    out.push({ tool: "claude code", state: claudeWiring(claude) });
     const cursor = join(homedir(), ".cursor", "mcp.json");
     out.push({
         tool: "cursor",
@@ -583,6 +623,46 @@ export function hostsRelay(url, port, localAddrs = localAddresses(), host = host
     const names = new Set(["localhost", "0.0.0.0", "::", "::1", host.toLowerCase(), `${host.toLowerCase()}.local`, ...localAddrs.map((a) => a.toLowerCase())]);
     return names.has(h) || /^127\./.test(h);
 }
+export function relayRowsWhenNoneHere(relays, port, reach = {}, hosts = (u, p) => hostsRelay(u, p)) {
+    const urls = [...new Set(relays.filter(Boolean))];
+    const local = (u) => hosts(u, port) || loopbackRelay(u);
+    const here = urls.filter(local);
+    if (!urls.length || here.some((u) => reach[u] !== true)) {
+        return [{ line: "not running", dim: here.length ? `start it with: pantheon start (your team${here.length === 1 ? "" : "s"} ${here.length === 1 ? "uses" : "use"} the relay on this machine)` : "start it with: pantheon start" }];
+    }
+    return urls.map((u) => {
+        let host = u;
+        try {
+            host = new URL(u.replace(/^ws/, "http")).host;
+        }
+        catch { }
+        const r = reach[u];
+        if (local(u))
+            return { line: `local     ${host}`, dim: "connected — a relay on this machine" };
+        const kind = /(?:^|\.)joinpantheon\.network$/i.test(host.replace(/:\d+$/, "")) ? "hosted    " : "remote    ";
+        return { line: `${kind}${host}`, dim: r === true ? "connected — no relay needs to run on this machine" : r === false ? "not reachable from this machine right now — pantheon doctor says why" : "no relay needs to run on this machine" };
+    });
+}
+export function loopbackRelay(url) {
+    let h;
+    try {
+        h = new URL(url.replace(/^ws/, "http")).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return h === "localhost" || h === "::1" || /^127\./.test(h);
+}
+export async function relayReachable(url, timeoutMs = 5_000) {
+    try {
+        const res = await fetch(`${url.replace(/^ws/i, "http").replace(/\/+$/, "")}/health`, { signal: AbortSignal.timeout(timeoutMs), redirect: "error" });
+        await res.body?.cancel().catch(() => { });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
 export function localAddresses() {
     try {
         return Object.values(networkInterfaces()).flatMap((l) => (l ?? []).map((a) => a.address));

package/dist/managed.js

@@ -255,8 +255,8 @@ export function joinInstructions(invite, relay, installers = true) {
         intro: "You're invited to my Pantheon team. Paste the line for your computer into a terminal:",
         steps,
         outro: sh || win
-            ? "It installs Pantheon (with its own Node, no admin rights), asks for your email, sends you a 6-digit code, and sets up the coding agents on your computer."
-            : "`pantheon join` asks for your email, sends you a 6-digit code, and sets up the coding agents on your computer.",
+            ? "It installs Pantheon (with its own Node, no admin rights), asks for your email, sends you a 6-digit code (check spam if it does not arrive), and sets up the coding agents on your computer."
+            : "`pantheon join` asks for your email, sends you a 6-digit code (check spam if it does not arrive), and sets up the coding agents on your computer.",
     };
 }
 export async function relayServesInstaller(relay, timeoutMs = 4000) {

package/dist/mcp.js

@@ -9,7 +9,7 @@ import { fenceBlock, fenceRubric, assess, fenceReminder } from "./untrusted.js";
 import { trusted, trustLabel } from "./verify-act.js";
 import { bindRepo, loadAll, resolveFor } from "./config.js";
 import { refuseSecrets, secretGuard } from "./secret-guard.js";
-import { LIMITS, SENDABLE } from "./protocol.js";
+import { LIMITS, SENDABLE, siblingSessions } from "./protocol.js";
 import { goalKindLabel, openedText } from "./worklist.js";
 import { VERSION } from "./version.js";
 import { installedVersion } from "./mcp-supervisor.js";
@@ -298,8 +298,7 @@ export async function runMcp() {
         const mine = client.myWork();
         const taken = client.takenBySibling();
         const peers = client.roster.filter((m) => m.id !== cfg.member);
-        const siblings = (client.roster.find((m) => m.id === cfg.member)?.sessions ?? [])
-            .filter((s) => s.id !== client.session);
+        const siblings = siblingSessions(client.roster, cfg.member, client.session);
         const warnSiblings = siblings.length && !siblingsWarned;
         if (siblings.length)
             siblingsWarned = true;
@@ -320,6 +319,9 @@ export async function runMcp() {
             taken.length
                 ? `taken by another of your sessions (leave these alone):\n${taken.map((o) => `  ${o.id}  ${o.kind} — ${o.body}`).join("\n")}`
                 : ``,
+            ...client.members.filter((e) => e.recovery).map((e) => e.member === cfg.member
+                ? `SOMEONE ASKED TO MOVE YOUR SEAT in ${cfg.space} to another device ("${e.recovery.label}", key ${e.recovery.fp}); it moves ${new Date(e.recovery.due_at).toISOString()} unless cancelled. Tell your human now. If they did not ask for it, they run  pantheon recover cancel ${e.member}  themselves, in a terminal, and secure their email account.`
+                : `seat move waiting: ${e.member} asked to move their seat to a new device ("${e.recovery.label}", key ${e.recovery.fp}). Your human may confirm it only after checking the key with ${e.member} themselves, by running  pantheon recover confirm ${e.member}  in a terminal (it asks them to type the key), or cancel it (pantheon recover cancel ${e.member}) — theirs to run, not yours.`),
         ].filter(Boolean).join("\n");
     };
     server.registerTool("pantheon_status", {