@tekmidian/pai 0.61.0 → 0.63.0

package/dist/{run-CxxZKEZw.mjs → run-CZVCCvXE.mjs}

@@ -1,8 +1,8 @@
-import { i as getRegistryBackend } from "./factory-EUUhSSoq.mjs";
+import { i as getRegistryBackend } from "./factory-BozZa81q.mjs";
 import { E as readWorkersSection, O as resolveModelCapability, T as providerKeyPath, b as isModelCapability, d as NATIVE_ANTHROPIC_MODELS, g as classModelCapability, h as assertProviderRunnable, k as resolveProviderKey, m as WorkersConfigError, n as claudeCommand, t as buildRunEnv } from "./run-env-BE5xyCwy.mjs";
 import { _ as statusPath, d as resolveTarget, f as setCooldown, g as panesDir, h as ledgerPath, i as capabilityForRun, m as eventsPath, n as ensureProxyRunning, o as isQuotaFailure, p as ensureNoMcpConfig, s as nextAutoProvider, t as DEFAULT_PROXY_PORT, u as resolveCapabilityRun, v as workersLogDir } from "./server-BY6AedmC.mjs";
 import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
+import { homedir, platform, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execFileSync, spawn } from "node:child_process";
 import { connect, createServer } from "node:net";
@@ -157,6 +157,72 @@ function describeMcp(config, claudeJson = CLAUDE_JSON) {
 	return lines;
 }
 
+//#endregion
+//#region src/workers/project-config.ts
+/**
+* project-config.ts — the project registry's optional launch pin, read for
+* the interactive branch of run.ts only: which MCP servers and built-in
+* tools a project's supervisor session (`pai worker run`, no -p) loads. Set
+* with `pai project mcp` / `pai project tools` (src/cli/commands/project/
+* session-config.ts), stored in the same `projects.session_config` JSON
+* column as the rest of a project's launch config. Unset = today's
+* behavior: every server, every tool.
+*
+* A standalone SQL lookup rather than importing the CLI's detectProject:
+* workers/ is a dependency of cli/, not the other way around.
+*/
+function asStringArray(v) {
+	if (!Array.isArray(v)) return void 0;
+	const out = v.filter((x) => typeof x === "string");
+	return out.length ? out : void 0;
+}
+/**
+* The launch config of the project whose root_path is `cwd` or an ancestor
+* of it (longest match wins) — null when no registered project covers it,
+* or when the matching project has no mcp/tools pin set. `registry` is
+* injectable for tests; production callers take the process-wide backend.
+*/
+async function projectLaunchConfig(cwd, registry) {
+	const target = resolve(cwd);
+	const rows = await (registry ?? await getRegistryBackend()).listProjectsByPathLengthDesc({ excludeArchived: true });
+	for (const row of rows) {
+		const root = resolve(row.root_path);
+		if (target !== root && !target.startsWith(root + "/")) continue;
+		if (!row.session_config) return null;
+		let parsed;
+		try {
+			parsed = JSON.parse(row.session_config);
+		} catch {
+			return null;
+		}
+		const mcp = asStringArray(parsed.mcp);
+		const tools = asStringArray(parsed.tools);
+		return mcp || tools ? {
+			slug: row.slug,
+			mcp,
+			tools
+		} : null;
+	}
+	return null;
+}
+/**
+* One line per active pin, so a pin never silently removes a server or tool:
+* shown by the SessionStart hook and by `pai worker run`'s interactive launch.
+* `claudeJson` is injectable for tests; read-only.
+*/
+function pinNotices(launch, claudeJson) {
+	if (!launch) return [];
+	const lines = [];
+	if (launch.mcp) {
+		const all = Object.keys(readMcpServers(claudeJson));
+		const loaded = all.filter((n) => launch.mcp.includes(n));
+		const missing = all.filter((n) => !launch.mcp.includes(n));
+		lines.push(`MCP pinned for ${launch.slug}: loading ${loaded.length} of ${all.length} servers; not loaded: ${missing.join(", ") || "(none)"} — \`pai project mcp --clear\` to load all`);
+	}
+	if (launch.tools) lines.push(`Tools pinned for ${launch.slug}: ${launch.tools.join(",")} — \`pai project tools --clear\``);
+	return lines;
+}
+
 //#endregion
 //#region src/workers/args.ts
 function parseRunnerArgs(argv) {
@@ -598,7 +664,7 @@ function worktreePath(logDir, id) {
 	return join(worktreesDir(logDir), id);
 }
 /** Run git in `cwd` with an optional env override, trimmed stdout, stderr on failure. */
-function runGit(cwd, args, env) {
+function runGit(cwd, args, env, timeout = 3e4) {
 	try {
 		return execFileSync("git", [
 			"-C",
@@ -606,7 +672,7 @@ function runGit(cwd, args, env) {
 			...args
 		], {
 			encoding: "utf8",
-			timeout: 3e4,
+			timeout,
 			stdio: [
 				"ignore",
 				"pipe",
@@ -621,8 +687,8 @@ function runGit(cwd, args, env) {
 	}
 }
 /** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
-function git(cwd, args) {
-	return runGit(cwd, args);
+function git(cwd, args, timeoutMs) {
+	return runGit(cwd, args, void 0, timeoutMs);
 }
 /** Is `cwd` inside a git repository (a .git dir — worktrees: a .git file)? */
 function isGitRepo(cwd) {
@@ -632,30 +698,23 @@ function isGitRepo(cwd) {
 		return false;
 	}
 }
-/**
-* Does the prompt read as a read-only task? Writing classes default to a
-* worktree; a prompt that only asks to look at things should not pay for one.
-* First-word verbs plus the explicit markers people actually write.
-*/
-function promptLooksReadonly(prompt) {
-	const p = prompt.trim();
-	if (!p) return true;
-	const firstLine = p.split("\n", 1)[0];
-	if (/\b(read[- ]only|do not (modify|change|edit|write)|don'?t (modify|change|edit|write)|no changes)\b/i.test(firstLine)) return true;
-	return /^(review|read|analy[sz]e|research|summar[iy]|inspect|investigate|spotcheck|report|find|list|check|verify|describe|explain|show)\b/i.test(p);
-}
-/** The classes whose runs write files and therefore default to a worktree. */
-const WORKTREE_CLASSES = [
-	"implement",
-	"complex",
-	"plan"
+/** Tools that can write to the checkout (Bash can, via the shell). */
+const WRITING_TOOLS = [
+	"Edit",
+	"Write",
+	"MultiEdit",
+	"NotebookEdit",
+	"Bash"
 ];
-/** Should this run get a worktree? Explicit flag first, then the default rule. */
+/** Can a run with these --allowedTools write? No restriction at all means yes. */
+function toolsCanWrite(allowedTools) {
+	const names = allowedTools.flatMap((e) => e.split(",")).map((s) => s.trim().replace(/\(.*$/, "")).filter(Boolean);
+	return !names.length || names.some((n) => WRITING_TOOLS.includes(n));
+}
+/** Should this run get a worktree? Explicit flag first, then: can it write? */
 function worktreeWanted(flag, opts) {
 	if (flag !== void 0) return flag;
-	if (!opts.className || !WORKTREE_CLASSES.includes(opts.className)) return false;
-	if (!isGitRepo(opts.cwd)) return false;
-	return !promptLooksReadonly(opts.prompt ?? "");
+	return toolsCanWrite(opts.allowedTools) && isGitRepo(opts.cwd);
 }
 /**
 * Commit `cwd`'s current index + working tree (including untracked files) as
@@ -699,11 +758,6 @@ function snapshotUncommitted(cwd, id, head) {
 * degrade to an in-place run.
 */
 function addWorktree(logDir, id, cwd) {
-	const swept = sweepOrphanWorktrees(logDir);
-	if (swept.length) appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
-		id,
-		note: `swept orphan worktree(s): ${swept.join(", ")}`
-	});
 	const dir = worktreePath(logDir, id);
 	const branch = worktreeBranch(id);
 	const head = git(cwd, ["rev-parse", "HEAD"]);
@@ -717,6 +771,7 @@ function addWorktree(logDir, id, cwd) {
 		branch,
 		base
 	]);
+	provisionDeps(logDir, id, cwd, dir);
 	return {
 		dir,
 		branch,
@@ -725,44 +780,60 @@ function addWorktree(logDir, id, cwd) {
 	};
 }
 /**
-* Remove worktrees (and their `worker/<id>` branches) whose worker no longer
-* exists — no status file left in the log dir. Killed and failed runs clean
-* up after themselves, but a `kill -9` or a crash strands a directory and a
-* branch; every worktree creation sweeps first so they cannot accumulate.
-* Directories younger than `minAgeMin` minutes are left alone: a run that is
-* just starting owns its worktree a moment before its status file exists.
+* Give the worktree its own dependencies so the worker never has to improvise
+* (symlinking node_modules to the main checkout, building in a /tmp copy).
+* A real node_modules directory in the main checkout is APFS-cloned
+* (`cp -c`, copy-on-write, near instant); elsewhere the lockfile installs it.
+* Never a symlink. Time-boxed and best effort: a failure is logged, the run
+* goes on.
 */
-function sweepOrphanWorktrees(logDir, minAgeMin = 10) {
-	const root = worktreesDir(logDir);
-	if (!existsSync(root)) return [];
-	const swept = [];
-	for (const ent of readdirSync(root, { withFileTypes: true })) {
-		if (!ent.isDirectory()) continue;
-		const id = ent.name;
-		const dir = join(root, id);
-		if (existsSync(statusPath(logDir, id))) continue;
-		try {
-			if ((Date.now() - statSync(dir).mtimeMs) / 6e4 < minAgeMin) continue;
-		} catch {}
-		let gitDir = null;
+function provisionDeps(logDir, id, cwd, wtDir) {
+	const note = (n) => appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
+		id,
+		note: n
+	});
+	try {
+		const main = join(git(cwd, ["rev-parse", "--show-toplevel"]), "node_modules");
+		const dest = join(wtDir, "node_modules");
+		if (!existsSync(main) || lstatSync(main).isSymbolicLink() || existsSync(dest)) return;
 		try {
-			const raw = git(dir, ["rev-parse", "--git-common-dir"]);
-			gitDir = isAbsolute(raw) ? raw : resolve(dir, raw);
+			git(wtDir, [
+				"check-ignore",
+				"-q",
+				"node_modules"
+			]);
 		} catch {
-			gitDir = null;
+			return;
 		}
-		removeWorktree(gitDir ?? dir, dir, true);
-		if (gitDir) try {
-			git(gitDir, ["worktree", "prune"]);
-			git(gitDir, [
-				"branch",
-				"-D",
-				worktreeBranch(id)
-			]);
+		const t0 = Date.now();
+		const opts = {
+			cwd: wtDir,
+			stdio: "ignore",
+			timeout: 18e4
+		};
+		if (platform() === "darwin") try {
+			execFileSync("cp", [
+				"-cR",
+				main,
+				dest
+			], opts);
+			note(`node_modules cloned (apfs) in ${Date.now() - t0}ms`);
+			return;
+		} catch {
+			rmSync(dest, {
+				recursive: true,
+				force: true
+			});
+		}
+		if (existsSync(join(wtDir, "bun.lock"))) execFileSync("bun", ["install", "--frozen-lockfile"], opts);
+		else if (existsSync(join(wtDir, "package-lock.json"))) execFileSync("npm", ["ci"], opts);
+		else return;
+		note(`node_modules installed from lockfile in ${Date.now() - t0}ms`);
+	} catch (e) {
+		try {
+			note(`node_modules provisioning failed: ${e.message}`);
 		} catch {}
-		swept.push(id);
 	}
-	return swept;
 }
 /** Commits the branch collected on top of its base. */
 function commitsSince(dir, base) {
@@ -788,6 +859,12 @@ function recordWorktree(logDir, status, info, ok) {
 		s.worktreeDir = info.dir;
 		s.worktreeBase = info.base;
 		s.worktreeSnapshot = info.snapshot;
+	} else if (safeCommitsSince(info.dir, info.base) > 0) {
+		s.branch = info.branch;
+		s.commits = commitsSince(info.dir, info.base);
+		s.worktreeDir = info.dir;
+		s.worktreeBase = info.base;
+		s.worktreeSnapshot = info.snapshot;
 	} else {
 		removeWorktree(s.cwd, info.dir, true);
 		try {
@@ -806,6 +883,37 @@ function recordWorktree(logDir, status, info, ok) {
 	saveStatus(logDir, s);
 	return s;
 }
+function safeCommitsSince(dir, base) {
+	try {
+		return commitsSince(dir, base);
+	} catch {
+		return 0;
+	}
+}
+/**
+* Salvage for an exit path (run finaliser, kill signal): commit whatever the
+* worker left uncommitted, log WORKER-SALVAGE, never throw. Bounded by
+* `timeoutMs` per git call. Returns the committed paths.
+*/
+function salvageOnExit(ledger, id, label, wtDir, timeoutMs) {
+	try {
+		const { committed, skipped } = salvageUncommitted(wtDir, label, timeoutMs);
+		if (committed.length) appendLedger(ledger, "WORKER-SALVAGE", {
+			id,
+			paths: committed.join(","),
+			skipped: skipped.length
+		});
+		return committed;
+	} catch (e) {
+		try {
+			appendLedger(ledger, "WORKER-NOTE", {
+				id,
+				note: `salvage failed: ${e.message}`
+			});
+		} catch {}
+		return [];
+	}
+}
 /** Remove a worktree directory from git's books and the filesystem. */
 function removeWorktree(cwd, dir, force) {
 	try {
@@ -831,17 +939,17 @@ function removeWorktree(cwd, dir, force) {
 * carry used; name-only, not porcelain: a worktree-only change renders as
 * " M path" and the shared git() helper trims that leading space away.
 */
-function uncommittedPaths(wtDir) {
+function uncommittedPaths(wtDir, timeoutMs) {
 	const tracked = git(wtDir, [
 		"diff",
 		"--name-only",
 		"HEAD"
-	]).split("\n").filter(Boolean);
+	], timeoutMs).split("\n").filter(Boolean);
 	const untracked = git(wtDir, [
 		"ls-files",
 		"--others",
 		"--exclude-standard"
-	]).split("\n").filter(Boolean);
+	], timeoutMs).split("\n").filter(Boolean);
 	return [...tracked, ...untracked];
 }
 /**
@@ -877,8 +985,8 @@ function symlinkEscapesWorktree(wtDir, relPath) {
 * as skipped instead. A failed commit throws with the worktree untouched:
 * its edits are still on disk, so nothing is lost.
 */
-function salvageUncommitted(wtDir, label) {
-	const paths = uncommittedPaths(wtDir);
+function salvageUncommitted(wtDir, label, timeoutMs) {
+	const paths = uncommittedPaths(wtDir, timeoutMs);
 	if (!paths.length) return {
 		committed: [],
 		skipped: []
@@ -894,14 +1002,16 @@ function salvageUncommitted(wtDir, label) {
 	try {
 		git(wtDir, [
 			"add",
+			"-A",
 			"--",
-			...toStage
-		]);
+			".",
+			...paths.filter((p) => !toStage.includes(p)).map((p) => `:(exclude,literal)${p}`)
+		], timeoutMs);
 		git(wtDir, [
 			"commit",
 			"-m",
 			`salvaged: ${label}`
-		]);
+		], timeoutMs);
 	} catch (e) {
 		throw new Error(`cannot salvage the uncommitted changes in ${wtDir} — ${e.message}; nothing was lost: commit them there by hand, then re-run merge`);
 	}
@@ -1215,6 +1325,139 @@ function inPlaceSystemPrompt() {
 		"Read-only git (status, diff, log, show, stash list) is fine."
 	].join("\n");
 }
+const GC_STAMP = "gc-last";
+/**
+* Archive worktrees of finished workers older than `olderThanHours` and
+* status-less orphan directories: uncommitted state is salvaged onto the
+* branch, the branch is x, the worktree is
+* removed. Nothing is deleted without a salvage first; a failed salvage skips
+* that worktree. Running workers are never touched. `dryRun` reports only.
+*/
+function gcWorktrees(logDir, olderThanHours = 24, dryRun = false, now = Date.now()) {
+	const cutoff = now - olderThanHours * 36e5;
+	const out = [];
+	const root = worktreesDir(logDir);
+	const known = /* @__PURE__ */ new Set();
+	const archive = (id, dir, repo, st) => {
+		const target = `refs/pai-archive/${id}`;
+		if (dryRun) return void out.push({
+			id,
+			archive: target
+		});
+		try {
+			if (!repo) throw new Error("not a git worktree");
+			const label = `archive: leftover state of worker ${id}`;
+			if (uncommittedPaths(dir).length) {
+				const res = salvageUncommitted(dir, label);
+				if (res.committed.length) git(dir, [
+					"commit",
+					"--amend",
+					"-q",
+					"-m",
+					label
+				]);
+				if (res.skipped.length && uncommittedPaths(dir).some((p) => !symlinkEscapesWorktree(dir, p))) throw new Error("uncommitted paths remain");
+			}
+			const src = worktreeBranch(id);
+			let hasBranch = true;
+			try {
+				git(repo, [
+					"rev-parse",
+					"--verify",
+					"-q",
+					`refs/heads/${src}`
+				]);
+			} catch {
+				hasBranch = false;
+			}
+			const tip = git(dir, ["rev-parse", "HEAD"]);
+			if (hasBranch) git(repo, [
+				"merge-base",
+				"--is-ancestor",
+				`refs/heads/${src}`,
+				tip
+			]);
+			git(repo, [
+				"update-ref",
+				target,
+				tip
+			]);
+			git(repo, [
+				"worktree",
+				"remove",
+				"--force",
+				dir
+			]);
+			if (hasBranch) git(repo, [
+				"branch",
+				"-D",
+				src
+			]);
+			if (st) saveStatus(logDir, {
+				...st,
+				branch: null,
+				worktreeDir: null,
+				archived: target
+			});
+			appendLedger(ledgerPath(logDir), "WORKER-GC", {
+				id,
+				archive: target
+			});
+			out.push({
+				id,
+				archive: target
+			});
+		} catch (e) {
+			out.push({
+				id,
+				skipped: e.message.split("\n")[0]
+			});
+		}
+	};
+	for (const st of loadStatuses(logDir)) {
+		known.add(st.id);
+		if (!st.worktreeDir || !existsSync(st.worktreeDir) || isLive(st)) continue;
+		let end = 0;
+		try {
+			end = statSync(statusPath(logDir, st.id)).mtimeMs;
+		} catch {
+			continue;
+		}
+		if (end > cutoff) continue;
+		archive(st.id, st.worktreeDir, st.cwd, st);
+	}
+	if (existsSync(root)) for (const ent of readdirSync(root, { withFileTypes: true })) {
+		if (!ent.isDirectory() || known.has(ent.name) || existsSync(statusPath(logDir, ent.name))) continue;
+		const dir = join(root, ent.name);
+		try {
+			if (statSync(dir).mtimeMs > cutoff) continue;
+		} catch {
+			continue;
+		}
+		let repo = null;
+		try {
+			const raw = git(dir, ["rev-parse", "--git-common-dir"]);
+			repo = isAbsolute(raw) ? raw : resolve(dir, raw);
+		} catch {
+			repo = null;
+		}
+		archive(ent.name, dir, repo, null);
+	}
+	if (!dryRun) for (const repo of new Set(loadStatuses(logDir).map((s) => s.cwd))) try {
+		git(repo, ["worktree", "prune"]);
+	} catch {}
+	return out;
+}
+/** Run `gcWorktrees` at most once per `everyMin` minutes (stamp file in the logDir). */
+function gcWorktreesThrottled(logDir, everyMin = 60, now = Date.now()) {
+	const stamp = join(logDir, GC_STAMP);
+	try {
+		if (now - statSync(stamp).mtimeMs < everyMin * 6e4) return null;
+	} catch {}
+	mkdirSync(logDir, { recursive: true });
+	writeFileSync(stamp, String(now), "utf8");
+	return gcWorktrees(logDir, 24, false, now);
+}
 
 //#endregion
 //#region src/workers/scope.ts
@@ -2782,54 +3025,6 @@ function relShort(p, cwd) {
 	return r && !r.startsWith("..") ? r : p;
 }
 
-//#endregion
-//#region src/workers/project-config.ts
-/**
-* project-config.ts — the project registry's optional launch pin, read for
-* the interactive branch of run.ts only: which MCP servers and built-in
-* tools a project's supervisor session (`pai worker run`, no -p) loads. Set
-* with `pai project mcp` / `pai project tools` (src/cli/commands/project/
-* session-config.ts), stored in the same `projects.session_config` JSON
-* column as the rest of a project's launch config. Unset = today's
-* behavior: every server, every tool.
-*
-* A standalone SQL lookup rather than importing the CLI's detectProject:
-* workers/ is a dependency of cli/, not the other way around.
-*/
-function asStringArray(v) {
-	if (!Array.isArray(v)) return void 0;
-	const out = v.filter((x) => typeof x === "string");
-	return out.length ? out : void 0;
-}
-/**
-* The launch config of the project whose root_path is `cwd` or an ancestor
-* of it (longest match wins) — null when no registered project covers it,
-* or when the matching project has no mcp/tools pin set. `registry` is
-* injectable for tests; production callers take the process-wide backend.
-*/
-async function projectLaunchConfig(cwd, registry) {
-	const target = resolve(cwd);
-	const rows = await (registry ?? await getRegistryBackend()).listProjectsByPathLengthDesc({ excludeArchived: true });
-	for (const row of rows) {
-		const root = resolve(row.root_path);
-		if (target !== root && !target.startsWith(root + "/")) continue;
-		if (!row.session_config) return null;
-		let parsed;
-		try {
-			parsed = JSON.parse(row.session_config);
-		} catch {
-			return null;
-		}
-		const mcp = asStringArray(parsed.mcp);
-		const tools = asStringArray(parsed.tools);
-		return mcp || tools ? {
-			mcp,
-			tools
-		} : null;
-	}
-	return null;
-}
-
 //#endregion
 //#region src/workers/codex.ts
 /**
@@ -3233,8 +3428,12 @@ async function runWorker(opts) {
 	if (!config.enabled) throw new Error("workers are off. Turn them on with: pai worker on\n(then the Agent-tool hook stops denying Anthropic subagents only when you do)");
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
+	try {
+		const gc = gcWorktreesThrottled(logDir)?.filter((r) => r.archive);
+		if (gc?.length) process.stderr.write(`pai worker: archived ${gc.length} leftover worktree(s) (pai worker gc)\n`);
+	} catch {}
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-D8jAr_sx.mjs");
+		const { runPlanner } = await import("./planner-DAQMTMjP.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -3445,10 +3644,21 @@ function interactiveMcpTools(explicitMcp, callerTools, projectLaunch) {
 * backgrounded a sub-worker and exited without waiting, the run must not
 * report success, whatever the process returned.
 */
+/** Per-git-call bound for the salvage a kill signal runs before exiting. */
+const SIGNAL_SALVAGE_MS = 5e3;
 async function finaliseRun(f) {
 	const { logDir, ledger, ok, rc } = f;
 	let { status, report } = f;
 	const wid = status.id;
+	const salvaged = f.worktree ? salvageOnExit(ledger, wid, status.label || UNLABELED, f.worktree.dir) : [];
+	if (salvaged.length) {
+		const msg = `WORKER-SALVAGE: committed uncommitted edits (${salvaged.join(", ")})`;
+		report = {
+			...report ?? {},
+			notes: [report?.notes ?? f.fallbackText, msg].filter(Boolean).join("\n"),
+			result: report?.result ?? "-"
+		};
+	}
 	const orphanReason = checkOrphanedChildren(logDir, wid);
 	const succeeded = ok && !orphanReason;
 	status.state = succeeded ? "done" : "failed";
@@ -3631,8 +3841,7 @@ async function executeRun(a) {
 	let worktree = null;
 	if (headless && !a.printCmd && worktreeWanted(a.worktreeFlag, {
 		cwd,
-		className: a.className,
-		prompt: parsed.prompt
+		allowedTools: parsed.allowedTools
 	})) try {
 		worktree = addWorktree(logDir, wid, cwd);
 	} catch (e) {
@@ -3673,6 +3882,12 @@ async function executeRun(a) {
 		const explicitMcp = [...a.mcpFlag ? [a.mcpFlag] : [], ...parsed.mcp];
 		const projectLaunch = await projectLaunchConfig(cwd);
 		const picked = interactiveMcpTools(explicitMcp, parsed.callerTools, projectLaunch);
+		const applied = projectLaunch && {
+			...projectLaunch,
+			mcp: explicitMcp.length ? void 0 : projectLaunch.mcp,
+			tools: picked.tools.length ? projectLaunch.tools : void 0
+		};
+		for (const line of pinNotices(applied)) console.error(line);
 		if (picked.mcpNames.length) mcpArgs = [
 			"--strict-mcp-config",
 			"--mcp-config",
@@ -3816,9 +4031,12 @@ async function executeRun(a) {
 			killed: 1,
 			label
 		});
-		if (worktree) try {
-			recordWorktree(logDir, status, worktree, false);
-		} catch {}
+		if (worktree) {
+			salvageOnExit(ledger, wid, label, worktree.dir, SIGNAL_SALVAGE_MS);
+			try {
+				recordWorktree(logDir, status, worktree, false);
+			} catch {}
+		}
 		cleanup();
 		try {
 			proc.kill();
@@ -4059,8 +4277,7 @@ async function executeCodexRun(a) {
 	let worktree = null;
 	if (worktreeWanted(a.worktreeFlag, {
 		cwd,
-		className: a.className,
-		prompt: parsed.prompt
+		allowedTools: parsed.allowedTools
 	})) try {
 		worktree = addWorktree(logDir, wid, cwd);
 	} catch (e) {
@@ -4165,9 +4382,12 @@ async function executeCodexRun(a) {
 			status.secs = Math.floor((Date.now() - t0) / 1e3);
 			status.last = `killed by signal ${sig}`;
 			saveStatus(logDir, status);
-			if (worktree) try {
-				recordWorktree(logDir, status, worktree, false);
-			} catch {}
+			if (worktree) {
+				salvageOnExit(ledger, wid, label, worktree.dir, SIGNAL_SALVAGE_MS);
+				try {
+					recordWorktree(logDir, status, worktree, false);
+				} catch {}
+			}
 			try {
 				proc.kill();
 			} catch {}
@@ -4374,5 +4594,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-export { UNLABELED as A, newWorkerId as B, workerInScope as C, worktreesDir as D, mergeWorker as E, elapsedOf as F, waitForTerminalStatus as G, ownsPid as H, isChatPane as I, shortText as J, longInlinePromptHint as K, isLive as L, alive as M, contextLabel as N, appendLedger as O, contextPercent as P, loadStatus as R, sessionTag as S, git as T, saveStatus as U, nowStamp as V, setWorkerLabel as W, expandMcpNames as X, describeMcp as Y, currentTabKey as _, projectLaunchConfig as a, resolveSession as b, handoffFromInside as c, workerDepth as d, checkPaneForWorker as f, markControlsHeld as g, clickrControlsArgv as h, usageContextTokens as i, ageOf as j, ledgerSummary as k, readInbox as l, openPaneForWorker as m, runWorker as n, parseWorkerReport as o, openFollowPane as p, parseRunnerArgs as q, testProvider as r, renderReport as s, printResult as t, sayToWorker as u, itermForClaudeSession as v, discardWorker as w, sessionMapPath as x, itermUuid as y, loadStatuses as z };
-//# sourceMappingURL=run-CxxZKEZw.mjs.map
+export { expandMcpNames as $, ledgerSummary as A, loadStatuses as B, discardWorker as C, uncommittedPaths as D, mergeWorker as E, contextPercent as F, setWorkerLabel as G, nowStamp as H, elapsedOf as I, parseRunnerArgs as J, waitForTerminalStatus as K, isChatPane as L, ageOf as M, alive as N, worktreesDir as O, contextLabel as P, describeMcp as Q, isLive as R, workerInScope as S, git as T, ownsPid as U, newWorkerId as V, saveStatus as W, pinNotices as X, shortText as Y, projectLaunchConfig as Z, itermForClaudeSession as _, parseWorkerReport as a, sessionMapPath as b, readInbox as c, checkPaneForWorker as d, openFollowPane as f, currentTabKey as g, markControlsHeld as h, usageContextTokens as i, UNLABELED as j, appendLedger as k, sayToWorker as l, clickrControlsArgv as m, runWorker as n, renderReport as o, openPaneForWorker as p, longInlinePromptHint as q, testProvider as r, handoffFromInside as s, printResult as t, workerDepth as u, itermUuid as v, gcWorktrees as w, sessionTag as x, resolveSession as y, loadStatus as z };
+//# sourceMappingURL=run-CZVCCvXE.mjs.map