@tekmidian/pai 0.61.0 → 0.62.0

package/dist/{run-CxxZKEZw.mjs → run-BVQZI79D.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";
@@ -598,7 +598,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 +606,7 @@ function runGit(cwd, args, env) {
 			...args
 		], {
 			encoding: "utf8",
-			timeout: 3e4,
+			timeout,
 			stdio: [
 				"ignore",
 				"pipe",
@@ -621,8 +621,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 +632,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 +692,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 +705,7 @@ function addWorktree(logDir, id, cwd) {
 		branch,
 		base
 	]);
+	provisionDeps(logDir, id, cwd, dir);
 	return {
 		dir,
 		branch,
@@ -725,44 +714,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 +793,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 +817,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 +873,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 +919,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 +936,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 +1259,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
@@ -3233,8 +3410,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-BG9ivPj0.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -3445,10 +3626,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 +3823,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) {
@@ -3816,9 +4007,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 +4253,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 +4358,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 +4570,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 { appendLedger as A, loadStatus as B, workerInScope as C, mergeWorker as D, git as E, contextLabel as F, saveStatus as G, newWorkerId as H, contextPercent as I, longInlinePromptHint as J, setWorkerLabel as K, elapsedOf as L, UNLABELED as M, ageOf as N, uncommittedPaths as O, alive as P, expandMcpNames as Q, isChatPane as R, sessionTag as S, gcWorktrees as T, nowStamp as U, loadStatuses as V, ownsPid as W, shortText as X, parseRunnerArgs as Y, describeMcp as Z, 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, ledgerSummary as j, worktreesDir as k, readInbox as l, openPaneForWorker as m, runWorker as n, parseWorkerReport as o, openFollowPane as p, waitForTerminalStatus 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, isLive as z };
+//# sourceMappingURL=run-BVQZI79D.mjs.map