@join-pantheon/cli 0.33.5 → 0.33.6-rc.1

package/dist/client.js

@@ -1,4 +1,5 @@
 import WebSocket from "ws";
+import { clearRemoval, recordRemoval, removalFor, removalHoldMs, removalRefusal, REMOVED_CHECK_MS, REMOVED_FIRST_MS, REMOVED_MAX_MS } from "./removed.js";
 import { adoptSpaceId, loadAll, rememberTeamRepos, updateMembershipToken } from "./config.js";
 import { honourClearedAuthority } from "./profile.js";
 import { markContinued } from "./continued.js";
@@ -35,9 +36,13 @@ export class PantheonClient {
     cid = 0;
     static REFUSED_RETRY_MS = 5 * 60_000;
     static REFUSED_GRACE_MS = 2 * 60_000;
+    static REMOVED_CHECK_MS = REMOVED_CHECK_MS;
     get refused() { return this.connected ? null : this.refusedCode; }
     refusedCode = null;
     refusedSince = 0;
+    get removedFrom() { return this.connected ? null : this.removal; }
+    removal = null;
+    refusedAsRemoval = false;
     seq = 0;
     readSeq = 0;
     head = 0;
@@ -180,6 +185,7 @@ export class PantheonClient {
                 return;
             }
             let settled = false;
+            this.refusedAsRemoval = false;
             let heard = false;
             const fail = reject;
             reject = (err) => fail(heard ? Object.assign(err, { relayAnswered: true }) : err);
@@ -277,6 +283,8 @@ export class PantheonClient {
                         this.connected = true;
                         this.pending = null;
                         this.refusedCode = null;
+                        this.removal = null;
+                        this.removedWaitMs = 0;
                         this.session = msg.session;
                         this.everConnected = true;
                         this.head = msg.seq;
@@ -317,12 +325,17 @@ export class PantheonClient {
                             this.spaceId = msg.space_id;
                             this.cfg.spaceId = msg.space_id;
                         }
+                        try {
+                            clearRemoval({ space: this.cfg.space, spaceId: this.cfg.spaceId ?? msg.space_id ?? null, relay: this.cfg.relay });
+                        }
+                        catch { }
                         this.repos = msg.repos ?? [];
                         this.keepRepos();
                         this.plan = msg.plan ?? null;
                         this.adoptKnownRepo();
                         this.backoff = 500;
                         this.roster = msg.roster;
+                        this.learnRelayNow(msg.now);
                         this.obligations = msg.obligations;
                         this.members = msg.members;
                         this.features = msg.features ?? [];
@@ -371,6 +384,7 @@ export class PantheonClient {
                         break;
                     case "roster":
                         this.roster = msg.roster;
+                        this.learnRelayNow(msg.now);
                         break;
                     case "obligations":
                         this.obligations = msg.list;
@@ -382,7 +396,7 @@ export class PantheonClient {
                         const fn = msg.cid ? this.acks.get(msg.cid) : undefined;
                         if (fn && msg.cid) {
                             this.acks.delete(msg.cid);
-                            fn({ id: msg.id, seq: msg.seq });
+                            fn({ id: msg.id, seq: msg.seq, ...(typeof msg.note === "string" && msg.note ? { note: msg.note.slice(0, 300) } : {}) });
                         }
                         break;
                     }
@@ -393,6 +407,15 @@ export class PantheonClient {
                             if (code && !this.refusedCode)
                                 this.refusedSince = Date.now();
                             this.refusedCode = code;
+                            const removed = code === "REVOKED" ? removalRefusal(this.lastError) : null;
+                            this.removal = removed;
+                            this.refusedAsRemoval = !!removed;
+                            if (removed) {
+                                try {
+                                    recordRemoval({ space: this.cfg.space, spaceId: this.cfg.spaceId ?? null, relay: this.cfg.relay, member: this.cfg.member }, removed.by);
+                                }
+                                catch { }
+                            }
                         }
                         if (msg.code === "SPACE_DELETED")
                             this.closed = true;
@@ -435,17 +458,64 @@ export class PantheonClient {
                     reject(new Error(this.lastError ?? "relay connection failed"));
                 }
                 const slow = !!this.refused && Date.now() - this.refusedSince >= PantheonClient.REFUSED_GRACE_MS;
-                const wait = slow ? PantheonClient.REFUSED_RETRY_MS : Math.round(this.backoff * (0.5 + Math.random()));
-                setTimeout(() => { if (!this.closed)
-                    this.connect().catch(() => { }); }, wait);
+                if (slow && this.removal && this.refusedAsRemoval)
+                    this.waitOutRemoval();
+                else {
+                    const wait = slow ? PantheonClient.REFUSED_RETRY_MS : Math.round(this.backoff * (0.5 + Math.random()));
+                    setTimeout(() => { if (!this.closed)
+                        this.connect().catch(() => { }); }, wait);
+                }
                 this.backoff = Math.min(this.backoff * 2, 15_000);
             };
             ws.on("close", down);
             ws.on("error", (e) => { this.lastError = String(e.message ?? e); down(); });
         });
     }
+    waitOutRemoval() {
+        const team = { space: this.cfg.space, spaceId: this.cfg.spaceId ?? null, relay: this.cfg.relay, member: this.cfg.member };
+        let rec = null;
+        try {
+            rec = removalFor(team);
+        }
+        catch {
+            rec = null;
+        }
+        this.removedWaitMs = Math.min(this.removedWaitMs ? this.removedWaitMs * 2 : REMOVED_FIRST_MS, REMOVED_MAX_MS);
+        const now = Date.now();
+        const until = Math.max(rec ? rec.last + removalHoldMs(rec) : 0, now + this.removedWaitMs);
+        const next = () => Math.max(1_000, Math.min(PantheonClient.REMOVED_CHECK_MS, until - Date.now()));
+        const tick = () => {
+            this.removalTimer = null;
+            if (this.closed || this.connected)
+                return;
+            let gone = false;
+            if (rec) {
+                try {
+                    gone = !removalFor(team);
+                }
+                catch {
+                    gone = false;
+                }
+            }
+            if (gone || Date.now() >= until) {
+                this.connect().catch(() => { });
+                return;
+            }
+            this.removalTimer = setTimeout(tick, next());
+        };
+        if (this.removalTimer)
+            clearTimeout(this.removalTimer);
+        this.removalTimer = setTimeout(tick, next());
+    }
+    removalTimer = null;
+    removedWaitMs = 0;
     handOff() {
         this.closed = true;
+        this.stopRenewing();
+        if (this.removalTimer) {
+            clearTimeout(this.removalTimer);
+            this.removalTimer = null;
+        }
         for (const w of this.waiters) {
             clearTimeout(w.timer);
             w.resolve([]);
@@ -463,6 +533,11 @@ export class PantheonClient {
     }
     close() {
         this.closed = true;
+        this.stopRenewing();
+        if (this.removalTimer) {
+            clearTimeout(this.removalTimer);
+            this.removalTimer = null;
+        }
         for (const w of this.waiters) {
             clearTimeout(w.timer);
             w.resolve([]);
@@ -764,8 +839,55 @@ export class PantheonClient {
         const o = this.obligations.find((x) => x.id === obligation);
         if (o)
             this.claimedByMe.set(o.id, o);
+        if (this.role === "worker") {
+            this.held.add(obligation);
+            this.startRenewing();
+        }
         return r;
     }
+    static CLAIM_RENEW_MS = 10 * 60_000;
+    held = new Set();
+    renewTimer = null;
+    startRenewing() {
+        if (this.renewTimer)
+            return;
+        this.renewTimer = setInterval(() => { void this.renewClaims(); }, PantheonClient.CLAIM_RENEW_MS);
+        this.renewTimer.unref?.();
+    }
+    stopRenewing() {
+        if (this.renewTimer) {
+            clearInterval(this.renewTimer);
+            this.renewTimer = null;
+        }
+    }
+    forgetClaim(id) {
+        this.held.delete(id);
+        if (!this.held.size)
+            this.stopRenewing();
+    }
+    get renewing() { return [...this.held]; }
+    async renewClaims() {
+        if (!this.connected)
+            return 0;
+        let renewed = 0;
+        for (const id of [...this.held]) {
+            if (!id.startsWith("cont:") && !this.obligations.some((o) => o.id === id)) {
+                this.held.delete(id);
+                continue;
+            }
+            try {
+                await this.rpc({ t: "claim", obligation: id });
+                renewed++;
+            }
+            catch (e) {
+                if (/^(NO_SUCH_OBLIGATION|NO_SUCH_ACT|NOT_YOURS|NOT_ALLOWED_TO_WAKE|PLAN_LIMIT): /.test(e.message))
+                    this.held.delete(id);
+            }
+        }
+        if (!this.held.size)
+            this.stopRenewing();
+        return renewed;
+    }
     dissolutionNotices(rec) {
         const out = [];
         for (const [id, o] of this.claimedByMe) {
@@ -851,12 +973,27 @@ export class PantheonClient {
         if (c.cwdRepoOrigin)
             c.repoOrigin = c.cwdRepoOrigin;
     }
-    reportWorkerState(state, detail, until) {
+    reportWorkerState(state, detail, until, idleMs, more = {}) {
+        const v2 = this.features.includes("worker-state-2");
+        const st = state === "unavailable" && !v2 ? "holding" : state;
+        const d = !v2 && more.reason ? `${detail ?? ""} [${more.reason}]`.trim() : detail;
+        const untilIn = until ? Math.max(0, Math.round(until - this.relayNow())) : undefined;
         try {
-            this.ws?.send(JSON.stringify({ t: "worker_state", state, ...(detail ? { detail: detail.slice(0, 200) } : {}), ...(until ? { until } : {}) }));
+            this.ws?.send(JSON.stringify({ t: "worker_state", state: st, ...(d ? { detail: d.slice(0, 200) } : {}), ...(until ? { until } : {}),
+                ...(v2 && untilIn !== undefined ? { until_in: Math.min(untilIn, 7 * 24 * 3600_000) } : {}),
+                ...(v2 && idleMs !== undefined ? { idle_ms: Math.max(0, Math.min(3_600_000, Math.round(idleMs))) } : {}),
+                ...(v2 && more.reason ? { reason: more.reason } : {}),
+                ...(v2 && more.ref && /^(cont:)?[a-z]{1,3}_[A-Za-z0-9_-]{4,64}$/.test(more.ref) ? { ref: more.ref } : {}),
+                ...(v2 && more.goal && /^[a-z]{1,3}_[A-Za-z0-9_-]{4,64}$/.test(more.goal) ? { goal: more.goal } : {}) }));
         }
         catch { }
     }
+    relayNow() { return Date.now() + this.relaySkewMs; }
+    relaySkewMs = 0;
+    learnRelayNow(now) {
+        if (typeof now === "number" && Number.isFinite(now) && now > 0)
+            this.relaySkewMs = now - Date.now();
+    }
     deleteSpace(confirm) {
         return this.rpc({ t: "delete_space", confirm });
     }

package/dist/doctor.js

@@ -6,7 +6,7 @@ import { describeWindows, scanMcpWindows } from "./mcp-windows.js";
 import { grantsSeen, measureMcp, toolsReport, HOST_STARTUP_ALLOWANCE_MS, STARTUP_WARN_MS } from "./measure.js";
 import { FEEDBACK_ADDRESS } from "./feedback.js";
 import { loadProfile, profileInitialized, reservedDomains, teamProfile, wakeMode } from "./profile.js";
-import { isApprovedWaker, loadPolicy, relayKnowsAdmitters, unsandboxedAllowed } from "./worker-policy.js";
+import { inWokenRun, isApprovedWaker, loadPolicy, relayKnowsAdmitters, requestReadinessRecheck, unsandboxedAllowed } from "./worker-policy.js";
 import { commandState } from "./command-state.js";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir, platform } from "node:os";
@@ -19,8 +19,11 @@ import { load, resolveFor, loadAll, configFor, CONFIG_PATH } from "./config.js";
 import { fingerprint, signChallenge, verifyChallenge } from "./identity.js";
 import { approvalSummary, chosenApproval, copilotMcpConfigFile, kiroMcpConfigFile, onPath } from "./install.js";
 import { hookState, readIntent, agentHookStates, repairNote } from "./notify.js";
-import { loadPersonas } from "./persona.js";
-import { workerProc, menubarProc, notifierProc } from "./machine.js";
+import { loadPersonas, olderTeammatesNote } from "./persona.js";
+import { workerProc, menubarProc, notifierProc, workerFlagRunMinutes } from "./machine.js";
+import { isCatchAllDomain } from "./protocol.js";
+import { probeLinuxSandbox, sandboxDoctorRow } from "./linux-sandbox.js";
+import { removalKey, removalRefusal, removals, removalWords, teamsOf } from "./removed.js";
 import { agentById, chooseAgent, describeChoice, detectAvailable, folderReaderLine, unattendedRefusal, skippedSummary, SANDBOXED_FOR_UNATTENDED } from "./agents.js";
 import { loginShellLookup, npmSpawn, onPathNamed, which, whichWindows } from "./which.js";
 import { VERSION } from "./version.js";
@@ -151,6 +154,18 @@ function newestRelease() {
         return null;
     }
 }
+function repoBoundToTeam(cfg) {
+    try {
+        const f = loadAll();
+        const m = f && Object.values(f.spaces ?? {}).find((x) => x.id === cfg.spaceId || x.name === cfg.space);
+        if (!f || !m)
+            return false;
+        return Object.entries(f.bindings ?? {}).some(([k, b]) => b.space === m.id && !k.startsWith("d_") && existsSync(join(b.path, ".git")));
+    }
+    catch {
+        return false;
+    }
+}
 export async function doctor(projectDir) {
     const out = [];
     const add = (level, name, detail, fix, share) => out.push({ level, name, detail, ...(fix ? { fix } : {}), ...(share ? { share } : {}) });
@@ -240,6 +255,10 @@ export async function doctor(projectDir) {
     }
     else if (here.reason === "stale")
         add("fail", "team", `this ${here.repo ? "repo" : "folder"} is bound to a team this machine has left (${here.binding?.space})`, "pantheon use <team> --here, or pantheon join <invite>", "bound to a team this machine has left");
+    for (const { team, record } of removals(teamsOf(loadAll())).filter((x) => x.record.team !== removalKey(cfg) && x.record.team !== `${cfg.relay}|${cfg.space}`)) {
+        const w = removalWords(team, record.by);
+        add("warn", "removed", `${w.by ? `${w.by} removed you` : "you were removed"} from "${w.name}" (${new Date(record.at).toISOString().slice(0, 10)}) — this machine stopped connecting to it and checks now and then (at most every 6 hours)`, `to come back, you need a new invite from someone in "${w.name}" (pantheon join <invite>) or for a member to let you back in (pantheon admit ${w.member}); to forget it here: pantheon leave "${w.name}"`, "removed from a team");
+    }
     if (here.repo && !here.repo.shared)
         add("warn", "team", "this repo has no origin remote", "DELIVERED must name a commit a teammate can fetch; add a remote before delivering", "repo has no origin remote");
     const nonce = "doctor-selftest";
@@ -251,6 +270,9 @@ export async function doctor(projectDir) {
     if (profileInitialized(prof)) {
         const owns = reservedDomains(teamProfile(prof, cfg.spaceId, cfg.space));
         add("pass", "profile", `${prof.human.display_name} — ${prof.human.title}${owns.length ? `; you personally decide: ${owns.join(", ")}` : "; no human-required domains yet"}`, undefined, `published, ${owns.length} human-required domain${owns.length === 1 ? "" : "s"}`);
+        const vague = Object.keys(teamProfile(prof, cfg.spaceId, cfg.space).authority).filter((d) => isCatchAllDomain(d));
+        if (vague.length)
+            add("warn", "profile", `your profile claims ${vague.map((d) => `"${d}"`).join(", ")} — not a decision area, so no decision is ever routed by it`, "running pantheon setup drops it — name the areas you decide personally: pantheon setup --decides deployment,pricing (or --decides none); it is never published either way", "claims a catch-all decision area");
     }
     else {
         add("warn", "profile", "no profile published — decisions cannot be routed to you, and a HUMAN_REQUIRED naming you arrives marked unverified", "pantheon profile set --name <you> --title <role> --human-required <domains you personally decide>", "none published");
@@ -305,6 +327,9 @@ export async function doctor(projectDir) {
     if (!inRepo && folderHere) {
         add("pass", "git", "a plain folder — messages, questions and decisions work here; code is handed over from a repo", undefined, "plain folder, no git needed");
     }
+    else if (!inRepo && !repoBoundToTeam(cfg)) {
+        add("info", "git", "not a git repo — fine: questions, answers and decisions work anywhere; only handing over code needs one", undefined, "no repo; not needed for messages and decisions");
+    }
     else if (!inRepo) {
         add("warn", "git", `${projectDir} is not a git repo`, "DELIVERED requires a pushed branch + commit, so the work needs to live in a repo you both clone", "not a git repo");
     }
@@ -321,6 +346,8 @@ export async function doctor(projectDir) {
     agents.length
         ? add("pass", "agent cli", agents.join(", "), undefined, agents.join(", "))
         : add("warn", "agent cli", "found none of claude / codex / cursor-agent / copilot / kiro-cli on PATH", "fine if you only drive agents through a GUI (Conductor, Cursor, VS Code, the Kiro IDE), but `pantheon worker` needs a CLI to spawn", "none of claude / codex / cursor-agent / copilot / kiro-cli on PATH");
+    if (!inWokenRun())
+        requestReadinessRecheck();
     if (agents.length) {
         try {
             let unsandboxedOk = false;
@@ -491,7 +518,9 @@ export async function doctor(projectDir) {
         }
         client.pending
             ? add("fail", "membership", "registered but not admitted", `ask an admitted member to run: pantheon admit ${cfg.member}   (confirm fingerprint ${fingerprint(cfg.publicKey)} with them by voice first)`, "registered, not admitted")
-            : ((r) => add("fail", "membership", `refused: ${r?.message ?? client.lastError ?? "unknown"}`, (r?.fix ?? "run pantheon status for the relay's reason").replace("<you>", cfg.member), `refused: ${r?.code ?? String(client.lastError ?? "unknown").split(/[\s:]/)[0]}`))(refusalOf(client.lastError ?? ""));
+            : removalRefusal(client.lastError)
+                ? ((r) => add("fail", "membership", `removed from "${cfg.space}"${r.by ? ` by ${r.by}` : ""} — this machine's worker, alerts and menu bar stopped connecting to it (they check now and then, at most every 6 hours)`, `to come back, you need a new invite from someone in "${cfg.space}" (pantheon join <invite>) or for a member to let you back in (pantheon admit ${cfg.member}); to forget it here: pantheon leave "${cfg.space}"`, "refused: removed from the team"))(removalRefusal(client.lastError))
+                : ((r) => add("fail", "membership", `refused: ${r?.message ?? client.lastError ?? "unknown"}`, (r?.fix ?? "run pantheon status for the relay's reason").replace("<you>", cfg.member), `refused: ${r?.code ?? String(client.lastError ?? "unknown").split(/[\s:]/)[0]}`))(refusalOf(client.lastError ?? ""));
         client.close();
         return out;
     }
@@ -620,10 +649,18 @@ export async function doctor(projectDir) {
             else
                 add("pass", "commands", `woken runs: ${cs.summary}`, undefined, cs.level === "off" ? "woken runs edit files only" : `woken runs may run commands (${cs.allowBash ? "--allow-bash" : "granted here"})`);
         }
+        {
+            const { loadPolicy, effectiveRunMinutes, describeRunMinutes, effectiveIdleSeconds, describeIdleSeconds } = await import("./worker-policy.js");
+            const wf = workerFlagRunMinutes();
+            const lim = wf !== null ? { minutes: wf, from: "flag" } : effectiveRunMinutes({ policy: loadPolicy() });
+            add("pass", "run limit", `${describeRunMinutes(lim)} — a run still going then is stopped, tried once more, then handed to you`, undefined, `${lim.minutes} min (${lim.from === "default" ? "default" : lim.from === "flag" ? "worker flag" : "set here"})`);
+            const idle = effectiveIdleSeconds({ policy: loadPolicy() });
+            add("pass", "idle wait", `${idle.seconds ? `${describeIdleSeconds(idle.seconds)} of quiet in your session before the worker takes a request` : "none — the worker takes a request as soon as no turn is in flight in your session"} (${idle.from === "default" ? "the default" : "set on this machine"}; pantheon policy set idle-seconds <0-900>)`, undefined, `${idle.seconds}s (${idle.from === "default" ? "default" : "set here"})`);
+        }
         if (cs.level !== "off" && host.platform === "linux") {
-            const missing = ["bwrap", "socat"].filter((b) => !onPathNamed(b, "linux"));
-            if (missing.length)
-                add("warn", "sandbox", `${missing.join(" and ")} not found — Claude Code's sandbox cannot start, so every woken command run will be refused`, "install them: sudo apt install bubblewrap socat (Debian/Ubuntu) or sudo dnf install bubblewrap socat (Fedora)", `sandbox tools missing: ${missing.join(", ")}`);
+            const r = sandboxDoctorRow(probeLinuxSandbox(), { container: host.kind === "container" });
+            if (r)
+                add(r.level, "sandbox", r.detail, r.fix, r.share);
         }
     }
     if (host.platform === "linux" && !host.ephemeral) {
@@ -673,6 +710,11 @@ export async function doctor(projectDir) {
         broken.length
             ? add("warn", "personas", `${personas.map((p) => p.name).join(", ")} — ${broken.map((p) => `${p.name}: ${p.warnings[0]}`).join("; ")}`, "a persona line that does not parse grants nothing and filters nothing — pantheon persona show <name>", `${personas.length}, ${broken.length} that do not parse`)
             : add("pass", "personas", `${personas.map((p) => p.name).join(", ")} — the worker only takes work a persona covers`, undefined, `${personas.length}`);
+        for (const p of personas) {
+            const n = olderTeammatesNote(p);
+            if (n)
+                add("warn", "personas", `${p.name} (committed in the repo) ${n}`, undefined, "a committed persona uses a key older versions do not know");
+        }
     }
     const open = [...client.goals.values()].filter((g) => g.state !== "CLOSED");
     const stateLine = `${client.head} acts in the ledger, ${open.length} open goal(s) — restored across relay restarts`;

package/dist/file-lock.js

@@ -147,11 +147,11 @@ export function brokenStateFix(broken) {
         parts.push(`repair or delete ${files.join(", ")} (one made read-only or locked: make it writable again; one that is a folder or not a file: delete it)`);
     return parts.join("; ");
 }
-export function withFileLock(f, fn) {
+export function withFileLock(f, fn, waitMs = WAIT_MS) {
     mkdirSync(dirname(f), { recursive: true, mode: 0o700 });
     const lock = `${f}.lock`;
     const token = `${process.pid} ${randomBytes(12).toString("hex")}`;
-    const deadline = Date.now() + WAIT_MS;
+    const deadline = Date.now() + waitMs;
     const made = `${lock}.${randomBytes(6).toString("hex")}.new`;
     writeFileSync(made, token, { mode: 0o600, flag: "wx" });
     try {

package/dist/git-safe.js

@@ -168,12 +168,16 @@ function hooksHash(common) {
     return h.digest("hex");
 }
 function cfgwtHash(gitdir) {
+    let body;
     try {
-        return createHash("sha256").update(readFileSync(join(gitdir, "config.worktree"))).digest("hex");
+        body = readFileSync(join(gitdir, "config.worktree"));
     }
     catch {
         return null;
     }
+    if (/^\uFEFF?[ \t\r\n]*$/.test(body.toString("utf8")))
+        return null;
+    return createHash("sha256").update(body).digest("hex");
 }
 function inspect(worktree, a, snapshot = false) {
     const common = a.common;

package/dist/home-guard.js

@@ -12,7 +12,9 @@ export const CONTINUED_FILE = "continued.json";
 export const CURSOR_FILE = "worker-cursor.json";
 export const PINS_FILE = "keys.json";
 export const NONCES_FILE = "nonces.json";
-export const GUARDED_FILES = [POLICY_FILE, CONFIG_FILE, PROFILE_FILE, HUD_FILE, CONTINUED_FILE, CURSOR_FILE, PINS_FILE, NONCES_FILE];
+export const REMOVED_FILE = "removed.json";
+export const RECHECK_FILE = "readiness-recheck.stamp";
+export const GUARDED_FILES = [POLICY_FILE, CONFIG_FILE, PROFILE_FILE, HUD_FILE, CONTINUED_FILE, CURSOR_FILE, PINS_FILE, NONCES_FILE, REMOVED_FILE, RECHECK_FILE];
 const sha = (b) => createHash("sha256").update(b).digest("hex");
 const read = (f) => { try {
     return statSync(f).isFile() ? readFileSync(f) : null;
@@ -195,8 +197,42 @@ export function narrowPolicy(before, now, keepAsks = askedHere) {
         out.wakeTeamFlag = flags;
     if ("wakeNo" in now || Object.keys(wakeNo).length)
         out.wakeNo = wakeNo;
+    const minutes = (x) => (typeof x === "number" && Number.isInteger(x) && x >= RUN_MINUTES_MIN && x <= RUN_MINUTES_MAX ? x : RUN_MINUTES_DEFAULT);
+    if (!same(b.runMinutes, now.runMinutes) && minutes(now.runMinutes) > minutes(b.runMinutes)) {
+        if ("runMinutes" in b)
+            out.runMinutes = b.runMinutes;
+        else
+            delete out.runMinutes;
+        keys.push("runMinutes raised");
+    }
+    if (!same(b.idleSeconds, now.idleSeconds)) {
+        if ("idleSeconds" in b)
+            out.idleSeconds = b.idleSeconds;
+        else
+            delete out.idleSeconds;
+        keys.push("idleSeconds changed");
+    }
     return { policy: out, keys };
 }
+export const RUN_MINUTES_DEFAULT = 60, RUN_MINUTES_MIN = 5, RUN_MINUTES_MAX = 180;
+export function narrowRemoved(before, now) {
+    const b = obj(before), n = obj(now);
+    const value = {};
+    const keys = [];
+    for (const [k, v] of Object.entries(n)) {
+        if (!(k in b)) {
+            keys.push(`${k} added`);
+            continue;
+        }
+        if (!same(b[k], v)) {
+            keys.push(`${k} changed`);
+            value[k] = b[k];
+            continue;
+        }
+        value[k] = v;
+    }
+    return { value, keys };
+}
 export function narrowConfig(before, now) {
     const keys = [];
     const out = { ...now };
@@ -444,7 +480,7 @@ export function restoreHome(s) {
                 continue;
             }
             const locked = (fn) => {
-                if (!(f.rel === PINS_FILE || f.rel === NONCES_FILE || f.rel === CONTINUED_FILE))
+                if (!(f.rel === PINS_FILE || f.rel === NONCES_FILE || f.rel === CONTINUED_FILE || f.rel === REMOVED_FILE))
                     return fn();
                 let ran = false;
                 try {
@@ -462,6 +498,25 @@ export function restoreHome(s) {
             catch {
                 writeFileSync(file, text, { mode: 0o600 });
             } };
+            if (f.rel === RECHECK_FILE) {
+                if (f.bytes)
+                    writeFileSync(file, f.bytes, { mode: 0o600 });
+                else
+                    rmSync(file, { force: true });
+                out.push({ rel: f.rel, what: f.bytes ? "reverted" : "removed", keys: [], quiet: true });
+                continue;
+            }
+            if (f.rel === REMOVED_FILE) {
+                locked(() => {
+                    const n = narrowRemoved(a, parse(read(file)));
+                    if (n.keys.length) {
+                        put(JSON.stringify(n.value, null, 2) + "\n");
+                        trustWrite(file);
+                        out.push({ rel: f.rel, what: "reverted", keys: n.keys, quiet: true });
+                    }
+                });
+                continue;
+            }
             if (f.rel === PINS_FILE || f.rel === NONCES_FILE) {
                 locked(() => {
                     const cur = parse(read(file));

package/dist/home-safety.js

@@ -16,6 +16,8 @@ export const PANTHEON_HOME_ENTRIES = [
     { name: "worker-policy.json", what: "the worker's wake policy", identity: true },
     { name: "spend.json", what: "the spend ledger", identity: true },
     { name: "personas", what: "the worker's personas", dir: true, identity: true },
+    { name: "removed.json", what: "the teams this machine was removed from", identity: true },
+    { name: "readiness-recheck.stamp", what: "the mark that has the worker look again for an agent it can run" },
     { name: "worker-state.json", what: "the worker's last state" },
     { name: "worker-run.json", what: "the worker's record of a run in flight" },
     { name: "run-slot.json", what: "the worker's run slot" },

package/dist/linux-sandbox.js

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { onPathNamed } from "./which.js";
+export function sandboxProbeArgs(weakerNested = false) {
+    return ["--unshare-user", "--unshare-pid", "--unshare-net", "--cap-drop", "ALL", "--die-with-parent", "--new-session",
+        "--ro-bind", "/", "/", ...(weakerNested ? ["--bind", "/proc", "/proc"] : ["--proc", "/proc"]), "--dev", "/dev", "true"];
+}
+export const SANDBOX_PROBE_ARGS = sandboxProbeArgs(false);
+export function claudeWeakerNested(home = homedir()) {
+    try {
+        const j = JSON.parse(readFileSync(join(home, ".claude", "settings.json"), "utf8"));
+        return j?.sandbox?.enableWeakerNestedSandbox === true;
+    }
+    catch {
+        return false;
+    }
+}
+export const SANDBOX_PROBE_TIMEOUT_MS = 5_000;
+const realRun = (cmd, args, timeoutMs) => {
+    const r = spawnSync(cmd, args, { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"], timeout: timeoutMs, killSignal: "SIGKILL" });
+    return { status: r.status, stderr: String(r.stderr ?? ""), timedOut: !!r.error && /ETIMEDOUT/.test(String(r.error.code ?? r.error.message)) };
+};
+export function probeLinuxSandbox(o = {}) {
+    if ((o.os ?? platform()) !== "linux")
+        return null;
+    const onPath = o.onPath ?? ((n) => onPathNamed(n, "linux"));
+    const missing = ["bwrap", "socat"].filter((b) => !onPath(b));
+    if (missing.length)
+        return { ok: false, missing };
+    let r;
+    try {
+        r = (o.run ?? realRun)("bwrap", sandboxProbeArgs(o.weakerNested ?? claudeWeakerNested()), SANDBOX_PROBE_TIMEOUT_MS);
+    }
+    catch (e) {
+        return { ok: false, error: e.message.split("\n")[0].slice(0, 200) };
+    }
+    if (r.status === 0)
+        return { ok: true };
+    const line = r.stderr.split("\n").map((l) => l.trim()).find(Boolean);
+    return { ok: false, error: r.timedOut ? `bwrap did not finish within ${SANDBOX_PROBE_TIMEOUT_MS / 1000} s` : (line ?? `bwrap exited ${r.status ?? "on a signal"}`).replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 200) };
+}
+const NAMESPACE_RE = /Operation not permitted|mount proc|setting up uid map|No permissions to create new namespace|user namespace|uid_map|Permission denied/i;
+export function sandboxAdvice(p, where) {
+    if (p.missing?.length) {
+        return {
+            says: `${p.missing.join(" and ")} not found — Claude Code's sandbox cannot start, so every woken command run will be refused`,
+            fix: "install them: sudo apt install bubblewrap socat (Debian/Ubuntu) or sudo dnf install bubblewrap socat (Fedora)",
+        };
+    }
+    const says = `Claude Code's sandbox cannot start here (${p.error ?? "bubblewrap failed"}) — every woken command run is refused, so runs can edit files but not test, commit or push`;
+    if (where.container) {
+        return { says, fix: "this looks like a container, which likely forbids the namespaces and /proc mount the sandbox needs: run the container privileged (or with user namespaces allowed), or run the worker on a VM or a real machine. Pantheon never runs commands outside the sandbox instead." };
+    }
+    if (NAMESPACE_RE.test(p.error ?? "")) {
+        return { says, fix: "likely cause: unprivileged user namespaces are restricted (Ubuntu 23.10+/24.04 do this with AppArmor). To lift it: sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0 — and to keep it after a reboot, put kernel.apparmor_restrict_unprivileged_userns=0 in /etc/sysctl.d/60-userns.conf. A narrower route is an AppArmor profile that allows bwrap to create user namespaces. Then run pantheon doctor again." };
+    }
+    return { says, fix: "run the probe yourself to see more: bwrap " + SANDBOX_PROBE_ARGS.join(" ") + " — then pantheon doctor again" };
+}
+export function sandboxDoctorRow(p, where) {
+    if (!p)
+        return null;
+    if (p.ok)
+        return { level: "pass", detail: "Claude Code's sandbox likely starts here (bubblewrap: user, pid and network namespaces, no capabilities, its /proc)", share: "sandbox likely starts" };
+    const a = sandboxAdvice(p, where);
+    return p.missing?.length
+        ? { level: "warn", detail: a.says, fix: a.fix, share: `sandbox tools missing: ${p.missing.join(", ")}` }
+        : { level: "fail", detail: a.says, fix: a.fix, share: `sandbox cannot start${where.container ? " (container)" : ""}` };
+}
+//# sourceMappingURL=linux-sandbox.js.map

package/dist/machine.js

@@ -162,7 +162,25 @@ function bareProc(kind) {
     }
     return { kind, running: false, managedBy: svc.managedBy ?? "none", ...svc };
 }
+export function runBy(p) {
+    if ((p.managedBy === "launchd" || p.managedBy === "systemd") && p.label)
+        return `service ${p.label}`;
+    if (p.managedBy === "host")
+        return `background host (${p.label ?? "the Pantheon task"})`;
+    return "started by hand";
+}
 export function workerProc() { return bareProc("worker"); }
+export function workerFlagRunMinutes(home = CONFIG_DIR, running = () => workerProc().running) {
+    try {
+        const s = JSON.parse(readFileSync(join(home, "worker-state.json"), "utf8"));
+        if (typeof s.run_minutes !== "number" || !Number.isFinite(s.run_minutes))
+            return null;
+        return running() ? s.run_minutes : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function notifierProc() { return bareProc("notifier"); }
 export function menubarProc() { return bareProc("menubar"); }
 const BARE_PATTERN = {

package/dist/mcp.js

@@ -23,6 +23,7 @@ import { protocol, sessionInstructions } from "./mcp-instructions.js";
 import { recentRuns } from "./spend.js";
 import { refusalOf } from "./refusal.js";
 import { signedRead } from "./reads.js";
+import { pickupEstimate } from "./pickup.js";
 const ACT_HELP = {
     NOTE: "FYI. Creates no obligation.",
     ASK: "A question a named peer owes you an answer to. Requires `to`.",
@@ -282,10 +283,8 @@ export async function runMcp() {
         const open = [...client.goals.values()].filter((g) => g.state !== "CLOSED");
         const reach = (p) => {
             const head = client.head;
-            const w = p.worker;
-            const worker = w?.state === "holding"
-                ? `; their worker is holding — ${w.detail ?? "deferring to a live session"}${w.until && w.until > Date.now() ? `, ~${Math.round((w.until - Date.now()) / 1000)}s more` : ""}`
-                : w?.state === "running" ? `; their worker is running${w.detail ? ` (${w.detail})` : ""}` : "";
+            const est = p.worker ? pickupEstimate(p, { now: client.relayNow() }) : null;
+            const worker = est && est.kind !== "soon" && est.kind !== "offline" ? `; ${est.says}` : "";
             return reachText(p, head) + worker;
         };
         const reachText = (p, head) => {
@@ -438,6 +437,14 @@ export async function runMcp() {
         return text(fmtAll(acts) +
             (work.length ? `\n\nYOURS TO HANDLE — pantheon_claim first:\n${work.map((o) => `  ${o.id}  ${o.kind} — ${o.body}`).join("\n")}` : ""));
     }));
+    const pickupLines = (to) => {
+        const mayWake = client.members.find((m) => m.member === cfg.member)?.may_wake;
+        const lines = to.filter((t) => t !== cfg.member).map((t) => {
+            const peer = client.roster.find((m) => m.id === t) ?? { id: t, sessions: [] };
+            return `  ${pickupEstimate(peer, { now: client.relayNow(), ...(mayWake !== undefined ? { mayWake } : {}) }).says}`;
+        });
+        return lines.length ? `\n\nwhen it will be picked up (tell your human if it is not soon):\n${lines.join("\n")}` : "";
+    };
     server.registerTool("pantheon_send", {
         title: "Send an act",
         description: `Say one thing to your peers, as a typed act. Acts:\n` +
@@ -512,7 +519,8 @@ export async function runMcp() {
                 ? `\n\nnote: this machine could not identify the request ${ref} (it was never read here and the relay did not serve it), so it is not recorded as answered — a copy of it arriving later would not be recognised. If one does, check with its sender before acting on it.`
                 : "";
         const linkNote = privateLinkNote(body, summary);
-        return text(`sent ${act} — id=${r.id} seq=${r.seq}${survived}${unrecorded}${linkNote ? `\n\nnote: ${linkNote}` : ""}\n\nNow call pantheon_wait to hear back.`);
+        const pickup = act === "ASK" ? pickupLines(to ?? []) : "";
+        return text(`sent ${act} — id=${r.id} seq=${r.seq}${pickup}${survived}${unrecorded}${linkNote ? `\n\nnote: ${linkNote}` : ""}\n\nNow call pantheon_wait to hear back.`);
     }));
     server.registerTool("pantheon_open_goal", {
         title: "Open a goal",