@join-pantheon/cli 0.33.1 → 0.33.2

package/dist/worker.js

@@ -20,19 +20,20 @@ import { agentSpawn, CmdLineUnsafe } from "./which.js";
 import { VERSION } from "./version.js";
 import { applyAnswer, CAPABILITY_ARGS, CARRY_REASON, carryOverWakers, dropLedgerGrants, hasWakeOnce, isApprovedWaker, mayAskWake, takeWakeOnce, OLD_RELAY_WAKE, relayKnowsAdmitters, loadPolicy, mayAsk, needsSelfUpgrade, parseGrantAnswer, recordAsk, savePolicy, useGrant, WOKEN_RUN_ENV, takeTeamFlagOnYes, unsandboxedAllowed, policyPath, isNewer, } from "./worker-policy.js";
 import { runtimeNodeVersion } from "./managed.js";
-import { agentHookStates, repairHook } from "./notify.js";
+import { agentHookStates, repairHook, repairNote } from "./notify.js";
 import { fence, assess } from "./untrusted.js";
 import { allowed, closeStartedRun, finishRun, recordRun, startRun } from "./spend.js";
-import { handledIn, loadContinued, markContinued, unmarkContinued } from "./continued.js";
+import { handledIn, loadContinued, markContinued, unmarkContinued, wakeAlertedKey } from "./continued.js";
 import { loadProfile, profileForTeam, reservedDecisionsNote, saveProfile, wakeMode } from "./profile.js";
 import { clip } from "./brief.js";
-import { composeWorker } from "./notice.js";
+import { composeWakeAsk, composeWorker } from "./notice.js";
 import { diagnoseRun, gitProbe, workNeedsCommands } from "./run-failure.js";
 import { installedTools, preferredTool } from "./notifier.js";
 import { loadPersonas, matchPersona, personaByName, personaMatches, effectivePolicy, personaBrief, describePersona, } from "./persona.js";
 import { CONFIG_PATH, loadAll, repoInfo, updateMembershipToken } from "./config.js";
 import { repoName, routeRequest, safeName } from "./repo-route.js";
 import { holdsRepo } from "./repo-find.js";
+import { FOLDER_SNAPSHOT_LIMITS, keepDrafts, removeSnapshot, shown, snapshotDrafts, snapshotRoot, sweepSnapshots, takeSnapshot } from "./folder-snapshot.js";
 import { gitActivity } from "./workdir.js";
 import { isContinuationFor, LIMITS, shouldDeferToHuman } from "./protocol.js";
 import { proxyEnvFor } from "./network.js";
@@ -273,6 +274,32 @@ export function outsideLinksDiagnosis(member, worktree, scan) {
         },
     };
 }
+const mb = (n) => (n < 1 << 20 ? `${Math.max(1, Math.round(n / 1024))} KB` : `${(n / (1 << 20)).toFixed(1)} MB`);
+export function limitWords(t) {
+    return t.what === "bytes" ? `${Math.round(t.limit / (1 << 20))} MB` : `${t.limit.toLocaleString("en-US")} ${t.what === "files" ? "files" : "folders"}`;
+}
+function skippedNote(k) {
+    const n = (x, one, many = `${one}s`) => `${x} ${x === 1 ? one : many}`;
+    const parts = [
+        k.links.length ? n(k.links.length, "link") : "",
+        k.secrets.length ? n(k.secrets.length, "secret-looking file or folder", "secret-looking files and folders") : "",
+        k.leftOut.length ? n(k.leftOut.length, ".git or node_modules folder", ".git and node_modules folders") : "",
+        k.other.length ? n(k.other.length, "special or unreadable file") : "",
+    ].filter(Boolean);
+    return parts.length ? ` — left out: ${parts.join(", ")}` : "";
+}
+export function folderTooLargeDiagnosis(member, name, t) {
+    const cap = `${FOLDER_SNAPSHOT_LIMITS.files.toLocaleString("en-US")} files and ${Math.round(FOLDER_SNAPSHOT_LIMITS.bytes / (1 << 20))} MB`;
+    return {
+        cause: "folder_too_large",
+        says: `the folder ${name} is too big to copy for a run (over ${limitWords(t)}, not counting .git, node_modules, links and secret-looking files) — a run works in a copy so that the folder itself is never changed, so none was started`,
+        fix: `Bind a smaller folder of documents to this team instead (pantheon use <team> --here inside it; a run copies up to ${cap}), or take this request in a live session.`,
+        peer: {
+            summary: `${member}'s worker did not start a run: the folder ${name} is too big to copy for one`,
+            body: `${member}'s worker answers from a copy of the folder ${name}, so that the folder itself is never changed — and it is over ${limitWords(t)}, too big to copy for a run. It is still owed and waits for ${member}. Nothing was run.`,
+        },
+    };
+}
 export function tamperedDiagnosis(member, e) {
     return {
         cause: "worktree_tampered",
@@ -568,16 +595,22 @@ sign in anywhere, enter, create or reveal a real password, token or key, or read
 `;
     return "";
 }
-export function workspaceNote(route, attached, sha, outbox) {
+export function workspaceNote(route, attached, sha, copy, readOnly = false, skipped) {
     const w = route.primary;
     const lines = ["", "", "WHERE YOU ARE"];
     if (w.kind === "folder") {
-        lines.push(`Your human's folder "${w.name}" is where this request belongs. You are in a scratch folder of your own (${outbox ?? "this folder"}): put any file you write for them there — they are drafts your human reviews. Their own folder is open to you to READ, never to change.`);
+        lines.push(`Your human's folder "${w.name}" is where this request belongs. You are working in a copy of it made for this run (${copy ?? "this folder"}): read it here.`);
+        lines.push(readOnly
+            ? `You can write nothing: answer in words, quoting what you found.`
+            : `Any file you write or change here is kept as a draft for your human to review; their own folder is never changed.`);
+        const out = skipped ? [skipped.secrets.length ? "secret-looking files (.env, keys, credentials)" : "", skipped.links.length ? "links" : "", skipped.leftOut.length ? ".git and node_modules" : ""].filter(Boolean) : [];
+        if (out.length)
+            lines.push(`Left out of the copy on purpose: ${out.join(", ")}. Do not go looking for them.`);
     }
     else {
         lines.push(`You are working in the ${w.name} repo${w.origin ? ` (${w.origin})` : ""}${sha ? ` at ${sha.slice(0, 7)}` : ""} — chosen because ${route.why}.`);
     }
-    const others = attached.filter((a) => a.path !== w.path || w.kind === "folder");
+    const others = attached.filter((a) => a.path !== w.path);
     if (others.length)
         lines.push(`Also open to READ only, never to edit: ${others.map((a) => `${a.name} (${a.kind === "folder" ? "a folder" : "repo"}) at ${a.path}`).join("; ")}.`);
     if (route.notHere.length)
@@ -1369,6 +1402,28 @@ export class Worker {
             }
             catch { }
         }
+        for (const e of client.members) {
+            const r = e.recovery;
+            if (!r)
+                continue;
+            const k = `seat-move-said:${e.member}:${r.fp}:${r.requested_at}`;
+            if (this.keyChangeSaid.has(k) || this.contDone.has(k))
+                continue;
+            this.keyChangeSaid.add(k);
+            this.markDone(k);
+            const mine = e.member === this.cfg.member;
+            this.opts.log(`! ${mine ? "someone asked to move YOUR seat" : `${e.member} asked to move their seat`} in ${this.cfg.space} to a new device ("${r.label}", key ${r.fp}) — ${mine ? `not you? pantheon recover cancel ${e.member}` : `check it with them, then pantheon recover confirm ${e.member} (or cancel)`}`);
+            try {
+                this.opts.notify?.({
+                    kind: "worker", who: "Your worker", context: this.cfg.space, ttl: 0, sound: true,
+                    heading: mine ? "Someone asked to move your seat" : `${e.member} asked to move their seat`,
+                    body: mine
+                        ? `A device signed in to your email account ("${r.label}", key ${r.fp}) asked for your seat in ${this.cfg.space}. It moves ${new Date(r.due_at).toLocaleString()} unless cancelled. Not you? In a terminal: pantheon recover cancel ${e.member} — and secure your email.`
+                        : `${e.member} signed in on a new device ("${r.label}", key ${r.fp}). Check the key with them on a call, then in a terminal: pantheon recover confirm ${e.member}. Not them? pantheon recover cancel ${e.member}.`,
+                });
+            }
+            catch { }
+        }
     }
     askedMembers = new Set();
     async tellWakeNo(client) {
@@ -1602,10 +1657,14 @@ export class Worker {
     async askWake(client, o, member) {
         const teams = [this.cfg.spaceId, this.cfg.space];
         const pol = loadPolicy(this.opts.home);
-        if (!mayAskWake(pol, teams, member))
-            return;
         const said = client.seenAct(o.ref)?.body ?? o.body;
         const what = clip((said.split("\n").find((l) => l.trim()) ?? said).replace(new RegExp(`^${member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")} asked:\\s*`, "i"), ""), 140);
+        if (!mayAskWake(pol, teams, member)) {
+            const open = Object.entries(pol.wakeAsks ?? {}).find(([, a]) => teams.includes(a.team) && a.member === member);
+            if (open)
+                this.alertWakeAsk(member, what, open[0]);
+            return;
+        }
         try {
             const ask = (again) => client.send({
                 act: "ESCALATE", goal: null, ref: o.ref, after_seq: Math.max(client.readSeq, client.seq),
@@ -1626,8 +1685,10 @@ export class Worker {
             let sent = await ask(false);
             let p = loadPolicy(this.opts.home);
             this.loadContinued();
-            if (p.wakeAsks?.[sent.id])
+            if (p.wakeAsks?.[sent.id]) {
+                this.alertWakeAsk(member, what, sent.id);
                 return;
+            }
             if (this.contDone.has(`wake-asked:${sent.id}`)) {
                 sent = await ask(true);
                 p = loadPolicy(this.opts.home);
@@ -1642,6 +1703,7 @@ export class Worker {
             savePolicy(p, this.opts.home);
             this.markDone(`wake-asked:${sent.id}`);
             this.opts.log(`* asked you whether ${member} may start work on this machine (their ${owedLabel(o.kind)} ${o.id} waits for the answer)`);
+            this.alertWakeAsk(member, what, sent.id);
             await client.send({
                 act: "NOTE", goal: o.goal, ref: o.ref, to: [member], after_seq: Math.max(client.readSeq, client.seq),
                 summary: `${this.cfg.member} has been asked to let you start work on their machine — this waits for that`,
@@ -1652,6 +1714,20 @@ export class Worker {
             this.opts.log(`! could not ask whether ${member} may wake this machine: ${e.message}`);
         }
     }
+    alertWakeAsk(member, what, focus) {
+        if (!this.opts.notify)
+            return;
+        const key = wakeAlertedKey(this.cfg.spaceId ?? this.cfg.space, member, focus);
+        this.loadContinued();
+        if (this.contDone.has(key))
+            return;
+        this.markDone(key);
+        try {
+            this.opts.notify(composeWakeAsk({ member, what, space: this.cfg.space, focus, mac: process.platform === "darwin" }));
+        }
+        catch { }
+        this.opts.log(`* alerted you: ${member} is waiting on your approval (once for this question)`);
+    }
     async routeFor(client, o, trigger, wokeBy) {
         const workspaces = this.workspaceList();
         const act = wokeBy ?? await this.fetchActById(o.ref);
@@ -1686,9 +1762,17 @@ export class Worker {
             return null;
         }
     }
-    async contextCheckout(w) {
-        if (w.kind === "folder")
-            return w.path;
+    async contextCheckout(w, goal, snaps) {
+        if (w.kind === "folder") {
+            const dir = join(snapshotRoot(this.opts.scratch, w.path), `${goal}-${Date.now().toString(36)}${randomBytes(2).toString("hex")}`);
+            const taken = await takeSnapshot(w.path, dir, this.opts.folderLimits ? { limits: this.opts.folderLimits } : {});
+            if (!taken.ok) {
+                this.opts.log(`  where   ${w.name} not copied for this run: ${taken.tooLarge ? `it is over ${limitWords(taken.tooLarge)}` : taken.error}`);
+                return null;
+            }
+            snaps.push({ ...taken.snap, kept: false });
+            return dir;
+        }
         const dir = join(this.opts.scratch, "ctx", createHash("sha256").update(w.fp ?? w.path).digest("hex").slice(0, 10));
         const sha = (await gitOut(w.path, ["rev-parse", "--verify", "HEAD^{commit}"]))?.trim();
         if (!sha || !/^[0-9a-f]{7,64}$/.test(sha))
@@ -1807,24 +1891,46 @@ export class Worker {
         };
     }
     async run() {
-        const fromSeq = this.readCursor();
+        const upkeep = !!(this.opts.housekeeping || this.opts.alertsOnly);
+        const fromSeq = upkeep ? 0 : this.readCursor();
         const client = new PantheonClient(this.cfg, (e) => {
             if ((e.t === "welcome" || e.t === "members") && this.client === client)
                 queueMicrotask(() => this.carryWakers(client));
         }, {
-            role: "worker",
+            role: upkeep ? "cli" : "worker",
+            ...(upkeep ? { upkeep: true } : {}),
             ...(fromSeq ? { fromSeq } : {}),
             persistToken: (space, oldToken, newToken) => { updateMembershipToken(space, oldToken, newToken); trustWrite(CONFIG_PATH); },
         });
         await client.connect();
         this.client = client;
         try {
-            await this.serve(client);
+            await (this.opts.alertsOnly ? this.sayKeyChanges(client) : this.opts.housekeeping ? this.keepHouse(client) : this.serve(client));
         }
         finally {
             client.close();
         }
     }
+    async keepHouse(client) {
+        this.dropLedgerGrants();
+        this.opts.log(`worker online as ${this.cfg.member} — upkeep only (self-upgrade, alerts): nothing is bound here, so teammates' requests wait for you`);
+        this.carryWakers(client);
+        while (!this.stopped) {
+            const arrived = await client.next(5000);
+            this.putHookBack();
+            await this.maintain(client, arrived);
+            this.sayKeyChanges(client);
+        }
+    }
+    putHookBack() {
+        const fixed = repairHook(this.opts.home);
+        if (!fixed)
+            return;
+        const note = repairNote(fixed.repairs);
+        this.opts.log(`! the wake-up hook had been removed — put it back${note?.recurring ? ` (${fixed.repairs} times now)` : ""}.`);
+        if (note?.why)
+            this.opts.log(`  ${note.why}.`);
+    }
     async serve(client) {
         const agentLabel = this.opts.agentCmd
             ? this.opts.agentCmd
@@ -1841,6 +1947,12 @@ export class Worker {
             this.opts.log(ws.length > 1 ? `  serves  ${ws.map((w) => `${w.name}${w.kind === "folder" ? " (folder)" : ""}`).join(", ")} — each request runs in the one it is about` : `  project ${resolve(this.opts.project)}`);
         }
         this.opts.log(`  scratch ${resolve(this.opts.scratch)}`);
+        try {
+            const gone = await sweepSnapshots(this.opts.scratch);
+            if (gone.length)
+                this.opts.log(`  cleanup removed ${gone.length} old folder cop${gone.length === 1 ? "y or transcript" : "ies and transcripts"} no run finished with`);
+        }
+        catch { }
         this.opts.log(`  agent   ${agentLabel}`);
         const cmds = commandState({ home: this.opts.home, project: this.opts.project, allowBash: this.opts.allowBash });
         this.opts.log(`  policy  ${this.opts.maxRunsPerHour} runs/hour, one at a time, commands ${cmds.level === "off" ? "off: edits only (bash gated)" : cmds.summary}`);
@@ -1876,11 +1988,7 @@ export class Worker {
             if (this.opts.continuations !== false)
                 this.enqueueContinuations(client, arrived);
             this.writeCursor(client.seq);
-            const fixed = repairHook(this.opts.home);
-            if (fixed) {
-                this.opts.log(`! the wake-up hook had been removed — put it back (${fixed.repairs} time${fixed.repairs === 1 ? "" : "s"} now).`);
-                this.opts.log(`  something on this machine rewrites ~/.claude/settings.json and drops the hooks key.`);
-            }
+            this.putHookBack();
             await this.maintain(client, arrived);
             if (this.running)
                 continue;
@@ -2416,6 +2524,17 @@ export class Worker {
         return true;
     }
     async runJob(client, o, persona, policy, makeBrief, requireReply, needsCommands = false, trigger = "", wokeBy = null) {
+        const snaps = [];
+        try {
+            return await this.runJobIn(client, o, persona, policy, makeBrief, requireReply, needsCommands, trigger, wokeBy, snaps);
+        }
+        finally {
+            for (const s of snaps)
+                if (!s.kept)
+                    await removeSnapshot(s.dir);
+        }
+    }
+    async runJobIn(client, o, persona, policy, makeBrief, requireReply, needsCommands, trigger, wokeBy, snaps) {
         const goal = o.goal ? (safeSegment(o.goal) ?? `goal-${createHash("sha256").update(o.goal).digest("hex").slice(0, 12)}`) : "adhoc";
         const gRec = this.client?.goals.get(goal);
         let branch = branchName(this.cfg.space, goal, gRec && (!client.signaturesExpected() || trusted(client.goalTrust(gRec).trust)) ? gRec.title : undefined);
@@ -2445,8 +2564,9 @@ export class Worker {
         const place = route.primary;
         const project = place.path;
         const sameAsDefault = resolve(project) === resolve(workspaceOf(this.opts.project).path);
-        const scratch = sameAsDefault ? this.opts.scratch : join(this.opts.scratch, `r-${createHash("sha256").update(place.fp ?? project).digest("hex").slice(0, 10)}`);
-        worktree = join(scratch, goal);
+        const scratch = place.kind === "folder" ? snapshotRoot(this.opts.scratch, project)
+            : sameAsDefault ? this.opts.scratch : join(this.opts.scratch, `r-${createHash("sha256").update(place.fp ?? project).digest("hex").slice(0, 10)}`);
+        worktree = place.kind === "folder" ? join(scratch, `${goal}-${Date.now().toString(36)}${randomBytes(2).toString("hex")}`) : join(scratch, goal);
         const { repo: _r, repoOrigin: _ro, cwdRepo: _cr, cwdRepoOrigin: _cro, ...bare } = this.cfg;
         const listed = place.kind === "repo" && !!place.fp && client.repos.some((r) => r.fingerprint === place.fp);
         const runCfg = sameAsDefault ? this.cfg : listed ? { ...bare, repo: place.fp, ...(place.origin ? { repoOrigin: place.origin } : {}) } : bare;
@@ -2511,41 +2631,46 @@ export class Worker {
                 this.lastFeaturesSaid = said;
             }
         }
-        if (place.kind === "folder" && !(features?.addDir && features?.settings)) {
-            const says = `The request is for the folder ${place.name}, and only Claude Code can be opened a folder to read without being able to change it — ${agentId ? `this machine's agent for unattended work is ${agentId}` : "no such Claude Code here"}.`;
-            const diagnosis = {
-                cause: "folder_needs_claude", says,
-                fix: "Install and sign in to Claude Code (claude) for woken runs, then pick it in  pantheon setup ; until then requests for this folder wait for a live session.",
-                peer: {
-                    summary: `${this.cfg.member}'s machine cannot answer from ${place.name} unattended — this waits for ${this.cfg.member}`,
-                    body: `${this.cfg.member}'s worker could not open the folder ${place.name} to read safely, so nothing was run. It is still owed and waits for ${this.cfg.member}'s live session.`,
-                },
-            };
-            if (!this.skipLogged.has(`refused:${o.id}`)) {
-                this.skipLogged.add(`refused:${o.id}`);
-                this.opts.log(`! not starting a run for ${o.kind} ${o.id}: ${says}`);
-            }
-            return { obligation: o, branch, worktree, ok: false, refused: true, detail: says, diagnosis, ...(choice && this.outagesPassed(choice).length ? { forOutage: true } : {}) };
-        }
+        const codexReadOnly = place.kind === "folder" && agentId === "codex" && !this.opts.agentCmd;
         const byCli = !!this.opts.agentCmd && !!this.opts.agentCmdFromCli;
         const noCommandsHere = features?.unknown ? "unknown"
             : features && ((choice?.backend.id === "claude-code" && !this.opts.agentCmd) || byCli) && !claudeSandboxable(features) && !this.unsandboxedOk() ? "unsandboxed"
                 : null;
         const wantedBash = policy.allowBash || (persona?.allowBash !== false && !!loadPolicy(this.opts.home).grants.run_commands);
         this.spentOnce = {};
-        let allowBash = noCommandsHere ? false : policy.allowBash || this.commandGrant(persona);
+        let allowBash = noCommandsHere || codexReadOnly ? false : policy.allowBash || this.commandGrant(persona);
         const bashDroppedForSandbox = noCommandsHere === "unsandboxed" && wantedBash;
         let baseRef = "", baseSha = "", tipSha = "";
         let fetched = null;
-        try {
-            ({ branch, worktree, baseRef, baseSha, tipSha, fetched } = await prepareWorktreeAsync(project, scratch, goal, this.opts.log, branch, this.repoBase(place.fp)));
+        let snap = null;
+        if (place.kind === "folder") {
+            const taken = await takeSnapshot(project, worktree, this.opts.folderLimits ? { limits: this.opts.folderLimits } : {});
+            if (!taken.ok && taken.tooLarge) {
+                const diagnosis = folderTooLargeDiagnosis(this.cfg.member, place.name, taken.tooLarge);
+                this.opts.log(`! not starting a run for ${o.kind} ${o.id}: ${diagnosis.says}`);
+                return { obligation: o, branch: "", worktree, ok: false, refused: true, detail: diagnosis.says, diagnosis };
+            }
+            if (!taken.ok) {
+                const detail = `could not copy the folder ${place.name} for the run: ${taken.error}`;
+                this.opts.log(`! ${detail}`);
+                return { obligation: o, branch: "", worktree, ok: false, detail };
+            }
+            snap = { ...taken.snap, kept: false };
+            snaps.push(snap);
+            branch = "";
+            this.opts.log(`  copy    ${taken.snap.files.size} file${taken.snap.files.size === 1 ? "" : "s"} (${mb(taken.snap.bytes)}) of ${place.name} into ${worktree}${skippedNote(taken.snap.skipped)}`);
         }
-        catch (e) {
-            if (e instanceof WorktreeTampered)
-                throw e;
-            const detail = `could not prepare a worktree: ${e.message}`;
-            this.opts.log(`! ${detail}`);
-            return { obligation: o, branch, worktree, ok: false, detail };
+        else {
+            try {
+                ({ branch, worktree, baseRef, baseSha, tipSha, fetched } = await prepareWorktreeAsync(project, scratch, goal, this.opts.log, branch, this.repoBase(place.fp)));
+            }
+            catch (e) {
+                if (e instanceof WorktreeTampered)
+                    throw e;
+                const detail = `could not prepare a worktree: ${e.message}`;
+                this.opts.log(`! ${detail}`);
+                return { obligation: o, branch, worktree, ok: false, detail };
+            }
         }
         const scan = outsideLinks(worktree);
         if (scan.links.length || scan.unreadable) {
@@ -2570,11 +2695,11 @@ export class Worker {
         const holdRepoConfig = !allowBash && !(features?.settingSources);
         const canPush = allowBash && !!branch;
         const attached = [];
-        const canAttach = !!features?.addDir && !!features?.settings;
-        const toAttach = place.kind === "folder" ? [place, ...route.context] : route.context;
+        const canAttach = (!!features?.addDir && !!features?.settings) || codexReadOnly;
+        const toAttach = route.context;
         if (canAttach) {
             for (const w of toAttach) {
-                const p = await this.contextCheckout(w);
+                const p = await this.contextCheckout(w, goal, snaps);
                 if (p)
                     attached.push({ name: w.name, path: p, kind: w.kind });
                 else
@@ -2586,7 +2711,7 @@ export class Worker {
             this.opts.log(`  where   this agent cannot be held to read-only, so ${toAttach.map((w) => w.name).join(", ")} ${toAttach.length === 1 ? "is" : "are"} named in its brief, not opened to it`);
         }
         const multi = this.workspaceList().length > 1 || place.kind === "folder" || route.notHere.length > 0;
-        const whereNote = multi ? workspaceNote(route, attached, tipSha || baseSha, place.kind === "folder" ? worktree : null) : "";
+        const whereNote = multi ? workspaceNote(route, attached, tipSha || baseSha, place.kind === "folder" ? worktree : null, codexReadOnly, snap?.skipped) : "";
         const reserved = reservedDecisionsNote(profileForTeam(this.cfg));
         const brief = makeBrief(branch, canPush) + whereNote + baseNote(baseRef, baseSha, fetched) +
             (allowBash ? (agentId === "claude-code" ? commandNote(worktree, tipSha || baseSha, (m) => this.opts.log(m)) : "") : holdRepoConfig ? heldNote() : "") +
@@ -2597,6 +2722,7 @@ export class Worker {
         let args;
         let env = agentBaseEnv(process.env, proxyEnvFor());
         let sp;
+        let plannedFiles;
         let bashRules = [];
         let fenced = null;
         if (!client.features.includes("delegate") && client.signaturesExpected()) {
@@ -2636,6 +2762,7 @@ export class Worker {
                 ...(baseSha ? { base: baseSha } : {}), ...(tipSha ? { commandsRev: tipSha } : {}), goal,
                 ...(features ? { claude: { features, pantheonHome: this.stateDir(), home: personHome, userSettings: join(personHome, ".claude", "settings.json"), ...(() => { const c = adoptedCommon(worktree); return c ? { gitCommon: c } : {}; })() } } : {}),
             });
+            plannedFiles = plan.writeFiles;
             for (const n of plan.notes ?? [])
                 if (!this.notesSaid.has(n)) {
                     this.notesSaid.add(n);
@@ -2757,7 +2884,8 @@ export class Worker {
                 this.cleanupStep("sealing the run home", () => this.sealRunHome(runHome));
                 this.cleanupStep("checking Pantheon's own files", () => this.restoreHomeAfterRun(homeBefore, o));
             }
-            const runLog = join(worktree, ".pantheon-run.log");
+            const logRoot = snap ? scratch : worktree;
+            const runLog = snap ? join(scratch, `${basename(worktree)}.run.log`) : join(worktree, ".pantheon-run.log");
             let extra = "";
             let massDelete = false;
             if (allowBash && baseSha) {
@@ -2773,7 +2901,7 @@ export class Worker {
                     this.opts.log(`! ${o.id}: the branch ${branch} deletes ${d.gone} of the ${d.total} files tracked at ${baseSha.slice(0, 7)} — do not merge it without looking`);
                 }
             }
-            this.writeRunLog(worktree, runLog, `obligation ${o.id}\nbranch ${branch}\n\n${detail}\n${extra}`);
+            this.writeRunLog(logRoot, runLog, `obligation ${o.id}\nbranch ${branch}\n\n${detail}\n${extra}`);
             const exited = /^exit 0/.test(detail);
             const sent = client.mineSince(startedAt, o.goal);
             const repliedWith = sent.find((a) => ["DELIVERED", "ANSWER", "ESCALATE", "ACCEPT", "OBJECT", "PROPOSE", "CONTRACT", "CLOSE", "WITHDRAW"].includes(a.act) || (a.act === "NOTE" && !!a.ref));
@@ -2784,17 +2912,27 @@ export class Worker {
             const ok = exited && replied;
             await this.checkDeliveries(client, sent, { branch, worktree, canPush: canPush && !massDelete, goal: o.goal ?? null });
             this.runProject = null;
-            if (place.kind === "folder") {
-                let drafts = [];
+            if (snap) {
+                const ours = new Set((plannedFiles ?? []).map((f) => (isAbsolute(f.path) ? relative(worktree, f.path) : f.path).split("\\").join("/")));
+                const pantheons = (rel) => rel.startsWith(".pantheon") || ours.has(rel);
+                let found = { drafts: [], complete: true };
                 try {
-                    drafts = readdirSync(worktree).filter((f) => !f.startsWith(".") && f !== "AGENTS.md" && f !== "CLAUDE.md");
+                    found = await snapshotDrafts(snap, pantheons);
                 }
-                catch { }
+                catch (e) {
+                    this.opts.log(`! could not look for drafts in ${worktree}: ${shown(e.message.split("\n")[0] ?? "")}`);
+                }
+                const drafts = found.drafts;
                 if (drafts.length) {
-                    this.opts.log(`  drafts  ${drafts.length} file${drafts.length === 1 ? "" : "s"} for ${place.name} in ${worktree}: ${drafts.slice(0, 5).join(", ")}${drafts.length > 5 ? ", …" : ""}`);
+                    snap.kept = true;
+                    const kept = await keepDrafts(worktree, found, { folder: place.path, at: Date.now() });
+                    if (kept.error)
+                        this.opts.log(`! ${kept.error}`);
+                    const names = `${drafts.slice(0, 8).join(", ")}${drafts.length > 8 ? `, and ${drafts.length - 8} more` : ""}`;
+                    this.opts.log(`  drafts  ${drafts.length}${found.complete ? "" : "+"} file${drafts.length === 1 ? "" : "s"} for ${place.name} in ${worktree}: ${names}`);
                     if (this.opts.notify) {
                         try {
-                            this.opts.notify({ kind: "worker", who: "Your worker", heading: `Drafts for ${place.name}`, context: this.cfg.space, body: `A request from ${(await this.actOf(client, o.ref))?.from ?? "a teammate"} left ${drafts.length} draft file${drafts.length === 1 ? "" : "s"} for you to review in ${worktree}. Nothing in ${place.path} was changed.`, ttl: 0, sound: false });
+                            this.opts.notify({ kind: "worker", who: "Your worker", heading: `Drafts for ${place.name}`, context: this.cfg.space, body: `A request from ${(await this.actOf(client, o.ref))?.from ?? "a teammate"} left ${drafts.length} draft file${drafts.length === 1 ? "" : "s"} for you to review in ${worktree}: ${names}. Nothing in ${place.path} was changed.`, ttl: 0, sound: false });
                         }
                         catch { }
                     }
@@ -2811,10 +2949,10 @@ export class Worker {
             const runKeys = client.features.includes("delegate");
             const sentAnywhere = client.mineSince(startedAt).some((a) => !runKeys || !a.sig || a.sig.role === "run");
             const outage = !ok && !exited && !sentAnywhere && choice && !/\(stopped after \d+s\)/.test(detail.split("\n")[0] ?? "") ? detectOutage(choice.backend.id, detail) : null;
+            const refusedLog = snap ? join(scratch, `${basename(worktree)}.${choice?.backend.id}-refused.run.log`) : join(worktree, `.pantheon-run.${choice?.backend.id}-refused.log`);
             if (outage) {
                 this.outages.set(choice.backend.id, outage);
-                const refusedLog = join(worktree, `.pantheon-run.${choice.backend.id}-refused.log`);
-                this.writeRunLog(worktree, refusedLog, `obligation ${o.id}\nbranch ${branch}\nagent ${choice.backend.label}\n\n${detail}\n`);
+                this.writeRunLog(logRoot, refusedLog, `obligation ${o.id}\nbranch ${branch}\nagent ${choice.backend.label}\n\n${detail}\n`);
                 if (Date.now() - startedAt < ONCE_GIVE_BACK_MS)
                     this.restoreOnces();
             }
@@ -2822,7 +2960,7 @@ export class Worker {
                 this.outageRetries.set(o.id, (this.outageRetries.get(o.id) ?? 0) + 1);
                 if (this.outageRetries.size > 200)
                     this.outageRetries.delete(this.outageRetries.keys().next().value);
-                this.opts.log(`! ${choice.backend.label} refused the run for ${o.id}: ${outage.why} — passed over until about ${whenAgain(outage.until)}; the request goes to the next agent here (transcript: ${join(worktree, `.pantheon-run.${choice.backend.id}-refused.log`)})`);
+                this.opts.log(`! ${choice.backend.label} refused the run for ${o.id}: ${outage.why} — passed over until about ${whenAgain(outage.until)}; the request goes to the next agent here (transcript: ${refusedLog})`);
                 return { obligation: o, branch, worktree, ok: false, detail, agentOut: true };
             }
             const quiet = ok && !requireReply && sent.length === 0;
@@ -2976,7 +3114,7 @@ export class Worker {
             });
             markContinued(space, key, this.opts.home);
             this.opts.log(d.cause === "agent_unavailable" ? `* told ${peer ?? "the teammate"} that ${o.id} waits: ${d.says}`
-                : `* told ${peer ?? "the teammate"} that ${o.id} waits for a live session: ${d.cause === "repo_not_here" ? d.says : "no agent here can take unattended work"}`);
+                : `* told ${peer ?? "the teammate"} that ${o.id} waits for a live session: ${d.cause === "repo_not_here" || d.cause === "folder_too_large" ? d.says : "no agent here can take unattended work"}`);
         }
         catch (e) {
             this.opts.log(`! could not tell the teammate that ${o.id} is waiting: ${e.message}`);