@join-pantheon/cli 0.33.6 → 0.33.7

package/README.md

@@ -787,3 +787,10 @@ notices the new version and switches to it within a minute, with no disconnect a
 reopen (windows opened on a pantheon older than 0.24 need one `/mcp` reconnect; `pantheon doctor`
 names them). A self-hosted relay is shared with your teammates, so it prints the restart for that
 and leaves the timing to you.
+
+**Going back to 0.33.6 or earlier after 0.33.7.** From 0.33.7 a woken run's DELIVERED is held on
+this machine until its branch is on origin (`held-deliveries.json` in the run home and in
+`~/.pantheon`), and the worker sends it once it has pushed. A release before 0.33.7 does not know
+those files: anything still held when you go back is never sent. Let the worker finish (or check
+that both files are gone) before you downgrade, and tell the teammate where the work is if one is
+left.

package/dist/agents.js

@@ -324,18 +324,21 @@ export function chooseAgent(preferred, opts = {}) {
     const first = live.find((o) => !NEEDS_SIGN_IN_BEFORE_SPAWN.has(o.backend.id)) ?? live[0];
     return { backend: first.backend, binary: first.binary, signIn: state(first.backend, first.binary), because: `${first.because} (none signed in)`, skipped };
 }
-export function unattendedRefusal(c, o = {}) {
+export function unattendedRefusalOf(c, o = {}) {
     if (NOT_FOR_UNATTENDED_RUNS.has(c.backend.id))
-        return KIRO_UNATTENDED_REFUSAL;
+        return { cause: "not_for_unattended", says: KIRO_UNATTENDED_REFUSAL };
     if (!SANDBOXED_FOR_UNATTENDED.has(c.backend.id) && !o.unsandboxedOk) {
-        return c.because === "pinned"
-            ? `woken runs here are pinned to ${c.backend.label} (a persona's agent: line, or the worker's --agent), which is set to leave teammates' requests for you, so this one waits for your next session. ` +
-                `To have ${c.backend.label} answer them: pantheon policy grant unsandboxed-runs — or unpin it so Claude Code takes them`
-            : unsandboxedRefusal(c.backend.label);
+        return { cause: "unsandboxed_off", says: c.because === "pinned"
+                ? `woken runs here are pinned to ${c.backend.label} (a persona's agent: line, or the worker's --agent), which is set to leave teammates' requests for you, so this one waits for your next session. ` +
+                    `To have ${c.backend.label} answer them: pantheon policy grant unsandboxed-runs — or unpin it so Claude Code takes them`
+                : unsandboxedRefusal(c.backend.label) };
     }
-    if (!NEEDS_SIGN_IN_BEFORE_SPAWN.has(c.backend.id) || c.signIn?.ok)
+    if (!(o.needsSignIn ?? NEEDS_SIGN_IN_BEFORE_SPAWN).has(c.backend.id) || c.signIn?.ok)
         return null;
-    return `${c.backend.label} is not signed in (${c.signIn?.detail ?? "not checked"}), and signed out it opens a browser to log in, so it is not started while you are away — ${SIGN_IN_CHECK[c.backend.id].fix}`;
+    return { cause: "not_signed_in", says: `${c.backend.label} is not signed in (${c.signIn?.detail ?? "not checked"}), and signed out it opens a browser to log in, so it is not started while you are away — ${SIGN_IN_CHECK[c.backend.id].fix}` };
+}
+export function unattendedRefusal(c, o = {}) {
+    return unattendedRefusalOf(c, o)?.says ?? null;
 }
 export function claudeInstallCommand(os = platform()) {
     return os === "win32" ? "irm https://claude.ai/install.ps1 | iex   (in PowerShell)" : "curl -fsSL https://claude.ai/install.sh | bash";
@@ -363,6 +366,13 @@ export function unattendedReadiness(o = {}) {
         ...AGENTS.filter((a) => NOT_FOR_UNATTENDED_RUNS.has(a.id)),
     ].filter((a, i, all) => all.findIndex((x) => x.id === a.id) === i);
     const found = [];
+    let othersSeen = null;
+    const others = () => (othersSeen ??= (() => {
+        for (const a of AGENTS)
+            if (a.id !== pinned?.id && !NOT_FOR_UNATTENDED_RUNS.has(a.id) && resolve(a))
+                return { claude: a.id === "claude-code", first: a };
+        return { claude: false, first: null };
+    })());
     let last = null;
     for (const b of order) {
         const bin = resolve(b);
@@ -371,15 +381,29 @@ export function unattendedReadiness(o = {}) {
         found.push({ backend: b, binary: bin });
         if (NOT_FOR_UNATTENDED_RUNS.has(b.id))
             continue;
-        const r = readinessFrom(found, { ...o, check });
+        const r = readinessFrom(found, { ...o, check, ...(pinned ? { others } : {}) });
         if (r.ok)
             return r;
         last = { r, n: found.length };
     }
-    return last && last.n === found.length ? last.r : readinessFrom(found, { ...o, check });
+    if (last && last.n === found.length)
+        return last.r;
+    return readinessFrom(found, { ...o, check, ...(pinned ? { others } : {}) });
 }
 function readinessFrom(given, o) {
     const os = o.os ?? platform();
+    const pin = o.pinned && o.pinned !== "auto" ? agentById(o.pinned) : undefined;
+    const others = o.others ?? (() => {
+        const rest = given.filter((a) => a.backend.id !== pin?.id && !NOT_FOR_UNATTENDED_RUNS.has(a.backend.id));
+        const claude = rest.find((a) => a.backend.id === "claude-code");
+        return { claude: !!claude, first: (claude ?? rest[0])?.backend ?? null };
+    });
+    const unpin = `unpin it (remove the persona's agent: line, or the worker's --agent)`;
+    if (pin && NOT_FOR_UNATTENDED_RUNS.has(pin.id) && given.some((a) => a.backend.id === pin.id)) {
+        const other = others().first;
+        return { ok: false, code: "kiro_only", pinned: true, short: `${pin.label} is set to leave requests for them`, says: `Teammates' requests wait for your next session here: woken runs are pinned to ${pin.label}, and ${KIRO_UNATTENDED_REFUSAL}.`,
+            fix: other ? `${unpin} so ${other.label} takes them` : `install Claude Code (${claudeInstallCommand(os)}), then ${unpin} so it takes them` };
+    }
     const available = given.filter((a) => !NOT_FOR_UNATTENDED_RUNS.has(a.backend.id));
     if (!available.length && (!o.pinned || o.pinned === "auto")) {
         const kiro = given.some((a) => a.backend.id === "kiro");
@@ -398,12 +422,15 @@ function readinessFrom(given, o) {
         const m = e.message;
         return { ok: false, code: /no agent CLI on PATH|is not on PATH/.test(m) ? "no_agent" : "no_agent_choice", short: m.replace(/ \(looked for .*\)$/, "").slice(0, 120), says: m, fix: "pantheon doctor names what is missing" };
     }
-    const refused = unattendedRefusal(choice, { ...(o.unsandboxedOk !== undefined ? { unsandboxedOk: o.unsandboxedOk } : {}) });
-    if (refused) {
-        return { ok: false, code: NOT_FOR_UNATTENDED_RUNS.has(choice.backend.id) ? "kiro_only" : "unsandboxed_off", short: `${choice.backend.label} is set to leave requests for them`, says: `Teammates' requests wait for your next session here: ${refused}`,
-            fix: `install Claude Code (${claudeInstallCommand(os)}) to have requests answered in its sandbox, or: pantheon policy grant unsandboxed-runs` };
+    const refused = unattendedRefusalOf(choice, { ...(o.unsandboxedOk !== undefined ? { unsandboxedOk: o.unsandboxedOk } : {}), ...(o.needsSignIn ? { needsSignIn: o.needsSignIn } : {}) });
+    if (refused && refused.cause !== "not_signed_in") {
+        const pinnedOff = choice.because === "pinned" && refused.cause === "unsandboxed_off";
+        const fix = pinnedOff
+            ? `pantheon policy grant unsandboxed-runs — or unpin ${choice.backend.label} (remove the persona's agent: line, or the worker's --agent) so Claude Code takes them${others().claude ? "" : ` (install it first: ${claudeInstallCommand(os)})`}`
+            : `install Claude Code (${claudeInstallCommand(os)}) to have requests answered in its sandbox, or: pantheon policy grant unsandboxed-runs`;
+        return { ok: false, code: refused.cause === "not_for_unattended" ? "kiro_only" : "unsandboxed_off", ...(pinnedOff ? { pinned: true } : {}), short: `${choice.backend.label} is set to leave requests for them`, says: `Teammates' requests wait for your next session here: ${refused.says}`, fix };
     }
-    if (choice.signIn && !choice.signIn.ok && !choice.signIn.unknown) {
+    if (refused || (choice.signIn && !choice.signIn.ok && !choice.signIn.unknown)) {
         return { ok: false, code: "not_signed_in", short: `${choice.backend.label} isn't signed in`, says: `${choice.backend.label} is installed but not signed in, so a request while you're away would fail.`,
             fix: SIGN_IN_CHECK[choice.backend.id].fix };
     }
@@ -600,6 +627,7 @@ export function headlessSpawn(opts) {
         const extra = [];
         let env = procEnv;
         let rulesOnArgv = bashRules;
+        let osSandbox = false;
         if (opts.claude && opts.runHome) {
             const runTmp = runTmpDir(opts.runHome);
             const c = claudeRunSettings({
@@ -624,6 +652,7 @@ export function headlessSpawn(opts) {
                 notes.push(...c.notes);
                 if (c.sandboxed)
                     env = { ...procEnv, ...sandboxCacheEnv(runTmp) };
+                osSandbox = "sandbox" in c.settings;
             }
             else if (f.disallowedTools) {
                 const deny = c.settings.permissions.deny;
@@ -655,6 +684,7 @@ export function headlessSpawn(opts) {
             writeFiles,
             ...(notes.length ? { notes } : {}),
             ...(extra.includes("--setting-sources") ? { repoSettingsIgnored: true } : {}),
+            ...(osSandbox ? { osSandbox: true } : {}),
         };
     }
     if (opts.backend.id === "codex") {

package/dist/claude-confine.js

@@ -1,9 +1,9 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { lstatSync, mkdirSync, readdirSync, readFileSync, rmdirSync, rmSync, statSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, statSync, unlinkSync } from "node:fs";
 import { writeInside } from "./safe-write.js";
 import { homedir, platform, tmpdir } from "node:os";
-import { isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { expectedLauncher, windowsManagedRoots } from "./managed.js";
 import { agentSpawn } from "./which.js";
 export const NO_CLAUDE_FEATURES = { version: null, permissionPrompts: false, settings: false, settingSources: false, disallowedTools: false };
@@ -130,9 +130,35 @@ export function absentDeniedPaths(common) {
     }
     return [...out].sort((a, b) => b.length - a.length);
 }
-export function removeSandboxLeftovers(absent) {
+export function leavesSandboxMounts(o) {
+    return o.os === "linux" && o.agent === "claude-code" && o.sandbox;
+}
+const bwrapFile = (st, anyMode = false) => st.isFile() && st.size === 0 && st.nlink === 1 && (anyMode || (st.mode & 0o222) === 0 || (st.mode & 0o777) === 0o666);
+function realFoldersBelow(root, dir) {
+    const rel = relative(root, dir);
+    if (rel.startsWith("..") || isAbsolute(rel))
+        return false;
+    let cur = root;
+    for (const part of rel ? rel.split(sep) : []) {
+        cur = join(cur, part);
+        try {
+            const st = lstatSync(cur);
+            if (!st.isDirectory() || st.isSymbolicLink())
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+export function removeSandboxLeftovers(absent, common) {
+    const root = resolve(common);
     const removed = [];
     for (const p of absent) {
+        if (!p.startsWith(root + sep) || !realFoldersBelow(root, dirname(p)))
+            continue;
+        const anyMode = p === join(root, "commondir");
         let st;
         try {
             st = lstatSync(p);
@@ -141,11 +167,14 @@ export function removeSandboxLeftovers(absent) {
             continue;
         }
         try {
-            if (st.isFile() && st.size === 0 && st.nlink === 1) {
-                rmSync(p, { force: true });
+            if (bwrapFile(st, anyMode)) {
+                const now = lstatSync(p);
+                if (!bwrapFile(now, anyMode) || now.ino !== st.ino || now.dev !== st.dev || !realFoldersBelow(root, dirname(p)))
+                    continue;
+                unlinkSync(p);
                 removed.push(p);
             }
-            else if (st.isDirectory() && readdirSync(p).length === 0) {
+            else if (st.isDirectory() && !st.isSymbolicLink() && readdirSync(p).length === 0) {
                 rmdirSync(p);
                 removed.push(p);
             }
@@ -154,6 +183,31 @@ export function removeSandboxLeftovers(absent) {
     }
     return removed;
 }
+export function ownWorktreeConfig(worktree, common) {
+    try {
+        const m = /^gitdir:\s*(.+?)\s*$/m.exec(readFileSync(join(worktree, ".git"), "utf8"));
+        if (!m)
+            return null;
+        const gitdir = realpathSync(resolve(worktree, m[1]));
+        const root = realpathSync(resolve(common));
+        return dirname(gitdir) === join(root, "worktrees") ? join(resolve(common), "worktrees", basename(gitdir), "config.worktree") : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function describeKept(paths) {
+    const out = [];
+    for (const p of paths) {
+        try {
+            const st = lstatSync(p);
+            const kind = st.isDirectory() ? "a folder" : st.isFile() ? "a file" : "not a file";
+            out.push(`${p}: ${kind}, ${st.size} bytes, mode ${(st.mode & 0o777).toString(8).padStart(4, "0")}, ${st.nlink} link${st.nlink === 1 ? "" : "s"}`);
+        }
+        catch { }
+    }
+    return out;
+}
 const inside = (child, parent) => {
     const r = relative(parent, child);
     return r === "" || (!!r && !r.startsWith("..") && !isAbsolute(r));

package/dist/cli.js

@@ -3017,6 +3017,14 @@ async function main() {
             const { unlinkSync, existsSync: exists, rmSync, readdirSync } = await import("node:fs");
             const spare = [];
             const hasConfig = !!all && exists(CONFIG_PATH);
+            if (!homeRefusal) {
+                const { heldDeliveriesLeft } = await import("./held-delivery.js");
+                const held = heldDeliveriesLeft(CONFIG_DIR);
+                if (held) {
+                    left.push(held);
+                    console.warn(`! ${held}`);
+                }
+            }
             if (homeRefusal) {
                 left.push(refusedHomeLine(CONFIG_DIR, homeRefusal));
             }

package/dist/client.js

@@ -630,10 +630,17 @@ export class PantheonClient {
         return this.sendAct(a);
     }
     async sendAct(a) {
+        return this.postAct(this.composeAct(a));
+    }
+    composeAct(a) {
         const repo = this.cfg.repo;
         const meta = a.act === "DELIVERED" && repo && !(a.meta && "repo" in a.meta) ? { ...(a.meta ?? {}), repo } : a.meta;
         const id = newActId();
         const sig = this.signAct(id, { ...a, ...(meta ? { meta } : {}) }, repo);
+        return { t: "act", id, ...a, ...(meta ? { meta } : {}), ...(repo ? { repo } : {}), sig };
+    }
+    async postAct(p) {
+        const { t: _t, id, sig: _s, repo: _r, ...a } = p;
         let unrecorded = false, unsignedRef = false;
         if (a.ref && this.ws?.readyState === WebSocket.OPEN && (a.act === "ANSWER" || a.act === "ACCEPT" || a.act === "OBJECT" || a.act === "DELIVERED")) {
             try {
@@ -644,7 +651,7 @@ export class PantheonClient {
             unrecorded = noted === false && this.signaturesExpected();
             unsignedRef = noted === "unsigned";
         }
-        const r = await this.rpc({ t: "act", id, ...a, ...(meta ? { meta } : {}), ...(repo ? { repo } : {}), sig });
+        const r = await this.rpc(p);
         let sentId = r.id === id ? id : null;
         if (r.id !== id && this.features.includes("act-sig")) {
             let prior = this.seen.get(r.id) ?? null;

package/dist/doctor.js

@@ -388,8 +388,9 @@ export async function doctor(projectDir) {
         }
     }
     const budget = instructionBudget(cfg);
-    const budgetLine = `${budget.chars} chars (~${budget.tokens} tokens) of session instructions per turn; the ${budget.protocolChars}-char protocol arrives with the first tool call instead`;
-    add(budget.chars > 1_200 ? "warn" : "pass", "mcp context", budgetLine, budget.chars > 1_200 ? "this used to be ~3,800 chars on every turn, and it competed with the work people asked for" : undefined, budgetLine);
+    const fromProfile = budget.chars - budget.fixedChars;
+    const budgetLine = `${budget.chars} chars (~${budget.tokens} tokens) of session instructions per turn — ${budget.fixedChars} Pantheon's own${fromProfile > 0 ? `, ${fromProfile} from your profile (who you are, what you reserved)` : ""}; the ${budget.protocolChars}-char protocol arrives with the first tool call instead`;
+    add(budget.fixedChars > 1_000 ? "warn" : "pass", "mcp context", budgetLine, budget.fixedChars > 1_000 ? "Pantheon's own part used to be ~3,800 chars on every turn, and it competed with the work people asked for" : undefined, budgetLine);
     const approval = chosenApproval();
     add("pass", "approval", approvalSummary(approval), `change with pantheon setup --ask-before-sending (or --approve-all); pantheon leave removes the Codex line`, approval);
     const measured = await measureMcp({ cwd: projectDir });

package/dist/held-delivery.js

@@ -0,0 +1,247 @@
+import { execFile, execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { normalizeOrigin } from "./config.js";
+import { withFileLock } from "./file-lock.js";
+import { actPayload, canonicalJson, verifyBytes, verifyDelegate } from "./identity.js";
+import { proxyEnvFor } from "./network.js";
+import { writeInside } from "./safe-write.js";
+export const HOLD_CONFIG = "delivery-hold.json";
+export const HELD_FILE = "held-deliveries.json";
+export const HELD_STATE = "held-deliveries.json";
+export const MAX_HELD_PER_RUN = 5;
+const capped = (list) => {
+    const sorted = [...list].sort((a, b) => (Number(a.at) || 0) - (Number(b.at) || 0));
+    const kept = sorted.slice(-MAX_HELD_PER_RUN);
+    return { kept, dropped: sorted.length - kept.length };
+};
+export const NOT_PUSHED = ["stopped", "not_own_branch", "not_allowed", "mass_delete", "push_refused"];
+const COMMIT_RE = /^[0-9a-f]{7,64}$/i;
+const BRANCH_RE = /^[A-Za-z0-9._][A-Za-z0-9._/-]{0,199}$/;
+const okBranch = (b) => typeof b === "string" && BRANCH_RE.test(b) && !b.includes("..") && !b.endsWith("/") && !b.endsWith(".lock");
+const str = (v) => typeof v === "string" && v.length > 0 && v.length < 4096;
+export const holdable = (branch, commit) => okBranch(branch) && typeof commit === "string" && COMMIT_RE.test(commit);
+export function sameRemote(a, b) {
+    if (a === b)
+        return true;
+    const x = normalizeOrigin(a), y = normalizeOrigin(b);
+    return !!x && x === y;
+}
+function writeAtomic(root, file, text) {
+    const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
+    try {
+        writeInside(root, tmp, text, 0o600);
+        renameSync(tmp, file);
+    }
+    catch (e) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { }
+        throw e;
+    }
+}
+function readList(file) {
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return { value: null, corrupt: null };
+    }
+    try {
+        return { value: JSON.parse(text), corrupt: null };
+    }
+    catch {
+        const aside = `${file}.corrupt-${Date.now()}`;
+        try {
+            renameSync(file, aside);
+        }
+        catch { }
+        return { value: null, corrupt: aside };
+    }
+}
+export function writeHoldConfig(runHome, c) {
+    if (!c) {
+        try {
+            rmSync(join(runHome, HOLD_CONFIG), { force: true });
+        }
+        catch { }
+        return;
+    }
+    writeAtomic(runHome, join(runHome, HOLD_CONFIG), JSON.stringify(c) + "\n");
+}
+export function readHoldConfig(runHome) {
+    try {
+        const c = JSON.parse(readFileSync(join(runHome, HOLD_CONFIG), "utf8"));
+        return c && str(c.origin) && !c.origin.startsWith("-") && okBranch(c.branch) ? { origin: c.origin, branch: c.branch } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function appendHeld(runHome, h) {
+    const file = join(runHome, HELD_FILE);
+    return withFileLock(file, () => {
+        const { value } = readList(file);
+        const list = Array.isArray(value) ? value.filter((x) => x?.frame?.id !== h.frame.id) : [];
+        const { kept, dropped } = capped([...list, h]);
+        writeAtomic(runHome, file, JSON.stringify(kept) + "\n");
+        return dropped;
+    });
+}
+export function takeHeldFrames(runHome, keep) {
+    const file = join(runHome, HELD_FILE);
+    return withFileLock(file, () => {
+        const { value, corrupt } = readList(file);
+        const all = Array.isArray(value)
+            ? value.filter((x) => !!x && typeof x === "object" && !!x.frame && typeof x.frame === "object")
+                .map((x) => ({ frame: x.frame, at: Number(x.at) || 0 }))
+            : [];
+        const { kept: frames, dropped } = capped(all);
+        keep(frames);
+        try {
+            rmSync(file, { force: true });
+        }
+        catch { }
+        return { corrupt, dropped };
+    });
+}
+export function corruptHeldFiles(dir, base = HELD_FILE) {
+    try {
+        return readdirSync(dir).filter((n) => n.startsWith(`${base}.corrupt-`)).map((n) => join(dir, n));
+    }
+    catch {
+        return [];
+    }
+}
+export function verifyHeldFrame(f, o) {
+    if (!f || typeof f !== "object" || f.t !== "act" || f.act !== "DELIVERED" || typeof f.id !== "string" || !/^a_[a-z0-9]{1,40}$/i.test(f.id) || typeof f.body !== "string")
+        return null;
+    const m = (f.meta ?? {});
+    if (!okBranch(m.branch) || typeof m.commit !== "string" || !COMMIT_RE.test(m.commit))
+        return null;
+    const sig = f.sig;
+    if (!sig || sig.role !== "run" || !sig.cert || sig.pub !== o.runPub || sig.cert.pub !== o.runPub || sig.cert.run !== o.runId)
+        return null;
+    if (canonicalJson(sig.meta ?? {}) !== canonicalJson(f.meta ?? {}) || (sig.repo ?? null) !== (f.repo ?? null))
+        return null;
+    const teams = o.teams.filter((t) => !!t);
+    try {
+        const vouched = teams.some((t) => verifyDelegate(o.memberPub, t, o.member, sig.cert, sig.cert.expires));
+        if (!vouched)
+            return null;
+        const ok = teams.some((team) => verifyBytes(sig.pub, actPayload({
+            id: f.id, team, member: o.member, keyRole: "run", nonce: sig.nonce, ts: sig.ts,
+            act: f.act, goal: f.goal ?? null, ref: f.ref ?? null, to: f.to ?? null,
+            defers_to: f.defers_to ?? null, affects: f.affects ?? null, repo: f.repo ?? null,
+            summary: f.summary ?? null, body: f.body, meta: f.meta ?? {},
+        }), sig.s));
+        return ok ? { branch: m.branch, commit: m.commit } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function asState(v) {
+    const s = v;
+    return { v: 1, runs: Array.isArray(s?.runs) ? s.runs : [], held: Array.isArray(s?.held) ? s.held : [] };
+}
+export function updateHeldState(stateDir, fn) {
+    const file = join(stateDir, HELD_STATE);
+    return withFileLock(file, () => {
+        const { value, corrupt } = readList(file);
+        const s = asState(value);
+        const before = JSON.stringify(s);
+        const result = fn(s);
+        const after = JSON.stringify(s);
+        if (after !== before) {
+            if (!s.runs.length && !s.held.length) {
+                try {
+                    rmSync(file, { force: true });
+                }
+                catch { }
+            }
+            else {
+                const tmp = `${file}.${process.pid}.tmp`;
+                writeFileSync(tmp, after + "\n", { mode: 0o600 });
+                renameSync(tmp, file);
+            }
+        }
+        return { result, corrupt };
+    });
+}
+export function heldDeliveriesLeft(home) {
+    const named = [];
+    const say = (meta) => {
+        const m = (meta ?? {});
+        named.push(typeof m.branch === "string" && typeof m.commit === "string" ? `${m.branch} at ${m.commit.slice(0, 7)}` : "a branch");
+    };
+    try {
+        const v = JSON.parse(readFileSync(join(home, HELD_STATE), "utf8"));
+        for (const h of Array.isArray(v.held) ? v.held : [])
+            say(h?.frame?.meta);
+    }
+    catch { }
+    let homes = [];
+    try {
+        homes = readdirSync(join(home, "run-homes"));
+    }
+    catch { }
+    for (const h of homes) {
+        try {
+            const v = JSON.parse(readFileSync(join(home, "run-homes", h, HELD_FILE), "utf8"));
+            for (const x of Array.isArray(v) ? v : [])
+                say(x?.frame?.meta);
+        }
+        catch { }
+    }
+    if (!named.length)
+        return null;
+    const n = named.length;
+    return `${n} deliver${n === 1 ? "y" : "ies"} a woken run held until ${n === 1 ? "its" : "their"} branch was on origin, never sent (${[...new Set(named)].join(", ")}) — ` +
+        `${n === 1 ? "it is" : "they are"} lost with Pantheon's files; tell your teammates where that work is (it is on those branches in this machine's checkouts)`;
+}
+let sshSet = null;
+function ownSshCommand(cwd, env) {
+    if (sshSet !== null)
+        return sshSet;
+    try {
+        sshSet = execFileSync("git", ["config", "--get", "core.sshCommand"], { cwd, env, encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "ignore"], timeout: 10_000 }).trim().length > 0;
+    }
+    catch {
+        sshSet = false;
+    }
+    return sshSet;
+}
+export function remoteTipIs(url, branch, commit, timeoutMs = 20_000) {
+    if (!str(url) || url.startsWith("-") || !okBranch(branch) || !COMMIT_RE.test(commit))
+        return Promise.resolve(null);
+    let cwd;
+    try {
+        cwd = mkdtempSync(join(tmpdir(), "pantheon-ls-remote-"));
+    }
+    catch {
+        return Promise.resolve(null);
+    }
+    const base = { ...process.env, ...proxyEnvFor(), GIT_TERMINAL_PROMPT: "0", GIT_CEILING_DIRECTORIES: tmpdir() };
+    const env = base.GIT_SSH_COMMAND || base.GIT_SSH || ownSshCommand(cwd, base) ? base : { ...base, GIT_SSH_COMMAND: "ssh -o BatchMode=yes" };
+    const args = ["-c", "core.fsmonitor=false", "-c", "protocol.file.allow=user", "ls-remote", "--", url, `refs/heads/${branch}`];
+    return new Promise((res) => {
+        execFile("git", args, { cwd, env, encoding: "utf8", windowsHide: true, timeout: timeoutMs, maxBuffer: 1 << 20 }, (err, out) => {
+            try {
+                rmSync(cwd, { recursive: true, force: true });
+            }
+            catch { }
+            if (err) {
+                res(null);
+                return;
+            }
+            const tip = (out.split("\n").find((l) => l.endsWith(`\trefs/heads/${branch}`)) ?? "").split("\t")[0].toLowerCase();
+            const c = commit.toLowerCase();
+            res(!!tip && (tip.startsWith(c) || c.startsWith(tip)));
+        });
+    });
+}
+//# sourceMappingURL=held-delivery.js.map

package/dist/home-safety.js

@@ -20,6 +20,8 @@ export const PANTHEON_HOME_ENTRIES = [
     { 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: "held-deliveries.json", what: "deliveries woken runs held until their branch was on origin (pantheon leave and uninstall name any not yet sent)" },
+    { name: /^held-deliveries\.json\.corrupt-\d+$/, sample: "held-deliveries.json.corrupt-1760000000000", what: "a record of held deliveries that could not be read, set aside" },
     { name: "run-slot.json", what: "the worker's run slot" },
     { name: "worker.pid", what: "the worker's pid file" },
     { name: /^notifier-state(-.+)?\.json$/, sample: "notifier-state-team%2Fone.json", what: "the alerts' state" },

package/dist/machine.js

@@ -773,6 +773,7 @@ export function removeHomeLeftovers(home, keep, opts = {}) {
         ["worker-policy.json", "the worker's wake policy (who may wake it, and self-upgrade) — a rejoin starts from no grants"],
         ["profile.json", "your profile (name, title, what you decide)"],
         ["spend.json", "the spend ledger"],
+        ["held-deliveries.json", "the deliveries woken runs held, not yet sent (named above)"],
         ["worker.pid", "the worker's pid file"],
         ["bin", "the menu bar's and alerts' files (the .command scripts, pantheon-hud, pantheon-tray)"],
     ];