@tekmidian/pai 0.54.1 → 0.56.0

package/dist/{run-DLG25bzt.mjs → run-CqRvXGjd.mjs}

@@ -1,6 +1,6 @@
-import { n as openRegistry, r as registryDbPath } from "./db-Ddns80yf.mjs";
-import { C as readWorkersSection, E as resolveProviderKey, S as providerKeyPath, T as resolveModelCapability, _ as isModelCapability, d as WorkersConfigError, f as assertProviderRunnable, p as classModelCapability } from "./config-B3EPzRjf.mjs";
-import { _ as ledgerPath, a as claudeCommand, b as workersLogDir, c as isQuotaFailure, f as resolveCapabilityRun, g as eventsPath, h as ensureNoMcpConfig, i as buildRunEnv, l as nextAutoProvider, m as setCooldown, n as ensureProxyRunning, o as capabilityForRun, p as resolveTarget, t as DEFAULT_PROXY_PORT, v as panesDir, y as statusPath } from "./server-CGiHdaUp.mjs";
+import { i as getRegistryBackend } from "./factory-DiuntvwG.mjs";
+import { C as readWorkersSection, E as resolveProviderKey, S as providerKeyPath, T as resolveModelCapability, _ as isModelCapability, d as WorkersConfigError, f as assertProviderRunnable, p as classModelCapability } from "./config-B93YS8tP.mjs";
+import { _ as ledgerPath, a as claudeCommand, b as workersLogDir, c as isQuotaFailure, f as resolveCapabilityRun, g as eventsPath, h as ensureNoMcpConfig, i as buildRunEnv, l as nextAutoProvider, m as setCooldown, n as ensureProxyRunning, o as capabilityForRun, p as resolveTarget, t as DEFAULT_PROXY_PORT, v as panesDir, y as statusPath } from "./server-CGuZFOeR.mjs";
 import { appendFileSync, closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
@@ -454,6 +454,18 @@ function ageOf(ts, now = /* @__PURE__ */ new Date()) {
 	const s = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
 	return s < 90 ? `${s}s` : `${Math.floor(s / 60)}m`;
 }
+/** Precise elapsed time: "45s", "1m 23s", "12m 05s", "1h 02m 05s" — seconds zero-padded after a larger unit. */
+function elapsedOf(ts, now = /* @__PURE__ */ new Date()) {
+	const t = Date.parse(ts.replace(" ", "T"));
+	if (Number.isNaN(t)) return "?";
+	const secs = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
+	const hours = Math.floor(secs / 3600);
+	const mins = Math.floor(secs % 3600 / 60);
+	const sec = secs % 60;
+	if (hours > 0) return `${hours}h ${String(mins).padStart(2, "0")}m ${String(sec).padStart(2, "0")}s`;
+	if (mins > 0) return `${mins}m ${String(sec).padStart(2, "0")}s`;
+	return `${sec}s`;
+}
 /** One-line description of a tool call, e.g. "Bash: npm test". */
 function describeTool(name, inp) {
 	if (typeof inp !== "object" || inp === null) return name;
@@ -563,8 +575,8 @@ function worktreeBranch(id) {
 function worktreePath(logDir, id) {
 	return join(worktreesDir(logDir), id);
 }
-/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
-function git(cwd, args) {
+/** Run git in `cwd` with an optional env override, trimmed stdout, stderr on failure. */
+function runGit(cwd, args, env) {
 	try {
 		return execFileSync("git", [
 			"-C",
@@ -577,7 +589,8 @@ function git(cwd, args) {
 				"ignore",
 				"pipe",
 				"pipe"
-			]
+			],
+			...env ? { env } : {}
 		}).trim();
 	} catch (e) {
 		const err = e;
@@ -585,6 +598,10 @@ function git(cwd, args) {
 		throw new Error(`git ${args.join(" ")} in ${cwd}: ${why.trim()}`);
 	}
 }
+/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
+function git(cwd, args) {
+	return runGit(cwd, args);
+}
 /** Is `cwd` inside a git repository (a .git dir — worktrees: a .git file)? */
 function isGitRepo(cwd) {
 	try {
@@ -618,7 +635,43 @@ function worktreeWanted(flag, opts) {
 	return !promptLooksReadonly(opts.prompt ?? "");
 }
 /**
-* Create the worktree and branch for `id` from `cwd`'s HEAD. Throws when git
+* Commit `cwd`'s current index + working tree (including untracked files) as
+* a floating commit on top of HEAD, without touching the real index, working
+* tree or HEAD: a temporary `GIT_INDEX_FILE` collects the snapshot, `git
+* commit-tree` writes the commit object directly (it updates no ref). The
+* caller then branches a worktree from that commit, so the worktree sees
+* exactly what was on disk, uncommitted or not.
+*/
+function snapshotUncommitted(cwd, id, head) {
+	const idxDir = mkdtempSync(join(tmpdir(), "pai-worktree-idx-"));
+	const idx = join(idxDir, "index");
+	try {
+		const env = {
+			...process.env,
+			GIT_INDEX_FILE: idx
+		};
+		runGit(cwd, ["read-tree", head], env);
+		runGit(cwd, ["add", "-A"], env);
+		return runGit(cwd, [
+			"commit-tree",
+			runGit(cwd, ["write-tree"], env),
+			"-p",
+			head,
+			"-m",
+			`worker ${id}: snapshot of uncommitted checkout`
+		]);
+	} finally {
+		rmSync(idxDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Create the worktree and branch for `id` from `cwd`'s HEAD — or, when the
+* checkout has uncommitted changes, from a snapshot commit of that dirty
+* state (see `snapshotUncommitted`), so a worktree worker sees the same
+* files the operator sees, not just what was last committed. Throws when git
 * refuses (no commits yet, branch exists, …) — the caller decides whether to
 * degrade to an in-place run.
 */
@@ -630,18 +683,22 @@ function addWorktree(logDir, id, cwd) {
 	});
 	const dir = worktreePath(logDir, id);
 	const branch = worktreeBranch(id);
-	const base = git(cwd, ["rev-parse", "HEAD"]);
+	const head = git(cwd, ["rev-parse", "HEAD"]);
+	const dirty = dirtyPaths(cwd).length > 0;
+	const base = dirty ? snapshotUncommitted(cwd, id, head) : head;
 	git(cwd, [
 		"worktree",
 		"add",
 		dir,
 		"-b",
-		branch
+		branch,
+		base
 	]);
 	return {
 		dir,
 		branch,
-		base
+		base,
+		snapshot: dirty
 	};
 }
 /**
@@ -707,6 +764,7 @@ function recordWorktree(logDir, status, info, ok) {
 		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 {
@@ -720,6 +778,7 @@ function recordWorktree(logDir, status, info, ok) {
 		s.worktreeDir = null;
 		s.worktreeBase = null;
 		s.commits = null;
+		s.worktreeSnapshot = null;
 	}
 	saveStatus(logDir, s);
 	return s;
@@ -839,6 +898,118 @@ function assertWorktreeClean(wtDir, id) {
 	const leftover = uncommittedPaths(wtDir);
 	if (leftover.length) throw new Error(`worker ${id}: the worktree ${wtDir} still holds uncommitted changes (${leftover.join(", ")}) — it was NOT removed; commit or copy them by hand, then re-run merge`);
 }
+/** Blob sha of `path` at `rev` in `cwd`, or null when it does not exist there. */
+function blobAt(cwd, rev, path) {
+	try {
+		return git(cwd, [
+			"rev-parse",
+			"--verify",
+			"-q",
+			`${rev}:${path}`
+		]);
+	} catch {
+		return null;
+	}
+}
+/** Blob sha of `path` as it sits on disk in `cwd`, or null when it is absent. */
+function workingBlob(cwd, path) {
+	if (!existsSync(join(cwd, path))) return null;
+	try {
+		return git(cwd, [
+			"hash-object",
+			"--",
+			path
+		]);
+	} catch {
+		return null;
+	}
+}
+/**
+* Refuse a snapshot merge when the checkout differs from the snapshot the
+* worker branched from, for any path the branch touched: the operator edited
+* it, or it was created/deleted since — applying the branch's diff on top
+* would silently discard that. Absent-in-both counts as equal.
+*/
+function assertNoSnapshotDrift(cwd, snapshot, paths, id) {
+	const drifted = paths.filter((p) => blobAt(cwd, snapshot, p) !== workingBlob(cwd, p)).sort();
+	if (!drifted.length) return;
+	throw new Error(`worker ${id}: the checkout ${cwd} has changed since the worktree's snapshot in paths the branch touches: ${drifted.join(", ")}. Resolve by hand, then re-run: pai worker merge ${id}. No merge was made; the worktree was kept.`);
+}
+/**
+* `pai worker merge <id>` for a snapshot-based worktree (see `addWorktree`):
+* git's own merge only moves committed history, and the snapshot commit was
+* never on any branch reachable from `cwd`'s HEAD, so there is nothing to
+* `git merge` here. Instead the worker's own changes — `git diff --binary
+* <snapshot> <branch>` — are applied straight onto the checkout's working
+* tree as uncommitted edits, exactly like the uncommitted state the worker
+* started from. Works even if `cwd`'s HEAD moved since the snapshot: the
+* diff is applied to files, not merged into a tree.
+*/
+function mergeSnapshotWorker(logDir, id, st) {
+	const snapshot = st.worktreeBase;
+	const branch = st.branch;
+	const worktreeDir = st.worktreeDir;
+	const salvaged = existsSync(worktreeDir) ? salvageUncommitted(worktreeDir, st.label || UNLABELED) : [];
+	if ((parseInt(git(st.cwd, [
+		"rev-list",
+		"--count",
+		`${snapshot}..${branch}`
+	]), 10) || 0) <= 0) throw new Error(`worker ${id}: branch ${branch} has no commits beyond its snapshot to merge. The worktree ${worktreeDir} was NOT removed — uncommitted work there would be destroyed. Commit it yourself, or drop everything with: pai worker discard ${id}`);
+	const changedPaths = git(st.cwd, [
+		"diff",
+		"--name-only",
+		snapshot,
+		branch
+	]).split("\n").filter(Boolean);
+	assertNoSnapshotDrift(st.cwd, snapshot, changedPaths, id);
+	const diff = execFileSync("git", [
+		"-C",
+		st.cwd,
+		"diff",
+		"--binary",
+		snapshot,
+		branch
+	], {
+		encoding: "utf8",
+		timeout: 3e4,
+		maxBuffer: 64 * 1024 * 1024
+	});
+	if (diff.trim()) try {
+		execFileSync("git", [
+			"-C",
+			st.cwd,
+			"apply",
+			"--binary"
+		], {
+			input: diff,
+			encoding: "utf8",
+			timeout: 3e4,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch (e) {
+		const err = e;
+		const why = (typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e);
+		throw new Error(`worker ${id}: git refused to apply ${branch}'s changes to ${st.cwd} — ${why.trim()}. The worktree ${worktreeDir} was kept: resolve by hand, then re-run merge`);
+	}
+	removeWorktree(st.cwd, worktreeDir, true);
+	try {
+		git(st.cwd, [
+			"branch",
+			"-D",
+			branch
+		]);
+	} catch {}
+	saveStatus(logDir, {
+		...st,
+		merged: true
+	});
+	const base = `applied worker ${id}'s changes (branch ${branch}) to ${st.cwd} as uncommitted changes: ${changedPaths.join(", ")} (worktree removed, branch deleted)`;
+	return salvaged.length ? `${base}; salvaged ${salvaged.length} uncommitted change(s) onto the branch first: ${salvaged.join(", ")}` : base;
+}
 /**
 * `pai worker merge <id>`: salvage whatever the worker left uncommitted onto
 * its branch, refuse when the original checkout is dirty in paths the branch
@@ -851,6 +1022,7 @@ function assertWorktreeClean(wtDir, id) {
 function mergeWorker(logDir, id) {
 	const st = mustHaveBranch(logDir, id);
 	if (st.merged) return `worker ${id}: branch ${st.branch} already merged`;
+	if (st.worktreeSnapshot) return mergeSnapshotWorker(logDir, id, st);
 	const salvaged = existsSync(st.worktreeDir) ? salvageUncommitted(st.worktreeDir, st.label || UNLABELED) : [];
 	if ((parseInt(git(st.cwd, [
 		"rev-list",
@@ -919,6 +1091,7 @@ function discardWorker(logDir, id) {
 		branch: null,
 		worktreeDir: null,
 		worktreeBase: null,
+		worktreeSnapshot: null,
 		commits: null,
 		merged: false
 	});
@@ -935,14 +1108,28 @@ function mustHaveBranch(logDir, id) {
 * own branch (the no-commit rule holds for the main branch only), it must not
 * merge or push itself, and the parent or operator merges.
 */
-function worktreeSystemPrompt(id, branch, dir) {
+function worktreeSystemPrompt(id, branch, dir, snapshot = false) {
 	return [
 		"You are running in your own git worktree:",
 		`  ${dir} on branch ${branch} (worker id ${id}).`,
 		"Commit your work on that branch as you go (git add / git commit) — committing here is expected;",
 		"the no-commit rule applies to the main branch only, and this is not it.",
 		"Do not merge, rebase or push; the operator merges your branch back with `pai worker merge`.",
-		"Use ONLY relative paths inside the worktree, never absolute worktree paths — absolute paths break after merge and leak machine layout."
+		"Use ONLY relative paths inside the worktree, never absolute worktree paths — absolute paths break after merge and leak machine layout.",
+		...snapshot ? ["This worktree was branched from a snapshot that includes files the parent checkout had uncommitted at spawn time — not just its last commit."] : []
+	].join("\n");
+}
+/**
+* For headless runs WITHOUT a worktree: the worker shares the operator's
+* checkout with other in-flight workers, so a hook blocks git stash (except
+* list/show), reset, clean, checkout/restore of paths, switch, rebase and
+* merge — take baselines from measurements before editing, not from stash.
+*/
+function inPlaceSystemPrompt() {
+	return [
+		"You are running in the operator's shared git checkout, alongside other workers editing it at the same time.",
+		"A hook blocks git stash (except list/show), reset, clean, checkout/restore of files, switch, rebase and merge — take baselines from measurements taken before you edit, not from stashing.",
+		"Read-only git (status, diff, log, show, stash list) is fine."
 	].join("\n");
 }
 
@@ -2333,6 +2520,53 @@ function renderReport(c, prefix, r, cwd = "") {
 	if (r.notes) out.push(`${prefix}${c("bold", "notes")}  ${shortText(r.notes, 120)}`);
 	return out;
 }
+/** A summary that names its own deletion — the path is expected to be gone. */
+const DELETED_RE = /\b(delete|deleted|deleting|remove|removed|removing)\b/i;
+/**
+* Check every path a report's `changed` list claims against the filesystem:
+* it must exist (mtime at or after `startMs`, the run's start) unless its
+* summary says it was deleted, in which case it must be absent. Mechanical
+* only — counts, row totals and other free-text claims are not checked (a
+* worker's R report is trusted as written; a 2026-09-23 report claimed "181
+* rows saved" while it had written 31, and only its listed paths are
+* something the filesystem can confirm or refute).
+*/
+function verifyReportChanges(changed, cwd, startMs) {
+	const failures = [];
+	for (const ch of changed ?? []) {
+		const raw = (ch.path ?? "").trim();
+		if (!raw) continue;
+		const abs = isAbsolute(raw) ? raw : resolve(cwd, raw);
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(abs).mtimeMs;
+		} catch {
+			mtimeMs = null;
+		}
+		if (DELETED_RE.test(ch.summary ?? "")) {
+			if (mtimeMs !== null) failures.push({
+				path: raw,
+				reason: "not-deleted"
+			});
+		} else if (mtimeMs === null) failures.push({
+			path: raw,
+			reason: "missing"
+		});
+		else if (mtimeMs < startMs) failures.push({
+			path: raw,
+			reason: "stale"
+		});
+	}
+	return {
+		ok: failures.length === 0,
+		failures
+	};
+}
+/** The one-line note appended to a report/ledger when verify fails. */
+function verifyFailNote(v) {
+	const paths = v.failures.map((f) => f.path).slice(0, 5).join(", ");
+	return `verify: ${v.failures.length} claimed change${v.failures.length === 1 ? "" : "s"} not confirmed: ${paths}`;
+}
 /** repo-relative display of a changed path when it lies under cwd. */
 function relShort(p, cwd) {
 	if (!cwd) return p;
@@ -2362,35 +2596,30 @@ function asStringArray(v) {
 /**
 * 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. `dbPath` is
-* injectable for tests; production callers take the default.
+* or when the matching project has no mcp/tools pin set. `registry` is
+* injectable for tests; production callers take the process-wide backend.
 */
-function projectLaunchConfig(cwd, dbPath = registryDbPath()) {
+async function projectLaunchConfig(cwd, registry) {
 	const target = resolve(cwd);
-	const db = openRegistry(dbPath);
-	try {
-		const rows = db.prepare(`SELECT root_path, session_config FROM projects WHERE status != 'archived' ORDER BY LENGTH(root_path) DESC`).all();
-		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;
+	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;
 		}
-		return null;
-	} finally {
-		db.close();
+		const mcp = asStringArray(parsed.mcp);
+		const tools = asStringArray(parsed.tools);
+		return mcp || tools ? {
+			mcp,
+			tools
+		} : null;
 	}
+	return null;
 }
 
 //#endregion
@@ -2770,7 +2999,7 @@ async function runWorker(opts) {
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-D3keWys5.mjs");
+		const { runPlanner } = await import("./planner-ye7wrrfB.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -3117,7 +3346,7 @@ async function executeRun(a) {
 		];
 	} else if (!headless && !parsed.callerMcpConfig) {
 		const explicitMcp = [...a.mcpFlag ? [a.mcpFlag] : [], ...parsed.mcp];
-		const projectLaunch = projectLaunchConfig(cwd);
+		const projectLaunch = await projectLaunchConfig(cwd);
 		const picked = interactiveMcpTools(explicitMcp, parsed.callerTools, projectLaunch);
 		if (picked.mcpNames.length) mcpArgs = [
 			"--strict-mcp-config",
@@ -3136,7 +3365,8 @@ async function executeRun(a) {
 	if (headless) {
 		cmd.push("--output-format", "stream-json", "--verbose", "--input-format", "stream-json");
 		if (!parsed.callerSystemPrompt) cmd.push("--append-system-prompt", workerContractPrompt(a.className, a.reportFormat));
-		if (worktree) cmd.push("--append-system-prompt", worktreeSystemPrompt(wid, worktree.branch, worktree.dir));
+		if (worktree) cmd.push("--append-system-prompt", worktreeSystemPrompt(wid, worktree.branch, worktree.dir, worktree.snapshot));
+		else cmd.push("--append-system-prompt", inPlaceSystemPrompt());
 	}
 	cmd = ensureToolSearch(cmd);
 	if (a.printCmd) {
@@ -3146,7 +3376,7 @@ async function executeRun(a) {
 		}));
 		return 0;
 	}
-	const status = {
+	let status = {
 		id: wid,
 		pid: process.pid,
 		label,
@@ -3175,7 +3405,8 @@ async function executeRun(a) {
 		...worktree ? {
 			worktreeDir: worktree.dir,
 			branch: worktree.branch,
-			worktreeBase: worktree.base
+			worktreeBase: worktree.base,
+			worktreeSnapshot: worktree.snapshot
 		} : {},
 		...a.specPath ? { spec: a.specPath } : {}
 	};
@@ -3377,6 +3608,20 @@ async function executeRun(a) {
 			} catch {}
 		}
 	}
+	if (headless && ctx.resultReport?.changed?.length) {
+		const verify = verifyReportChanges(ctx.resultReport.changed, worktree?.dir ?? cwd, t0);
+		if (!verify.ok) {
+			status.reportValid = false;
+			const note = verifyFailNote(verify);
+			status.last = shortText(note, 90);
+			ctx.resultReport.notes = ctx.resultReport.notes ? `${ctx.resultReport.notes} — ${note}` : note;
+			appendLedger(ledger, "REPORT-UNVERIFIED", {
+				id: wid,
+				failures: verify.failures.length,
+				paths: verify.failures.map((f) => f.path).slice(0, 5).join(",")
+			});
+		}
+	}
 	saveStatus(logDir, status);
 	appendLedger(ledger, "WORKER-END", {
 		id: wid,
@@ -3389,7 +3634,7 @@ async function executeRun(a) {
 		tools: status.tools,
 		label
 	});
-	if (worktree) recordWorktree(logDir, status, worktree, ok);
+	if (worktree) status = recordWorktree(logDir, status, worktree, ok);
 	if (headless && !a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, ctx.resultReport, worktreeExtras(status));
 	const resultText = resultEvent?.result ?? "";
 	if (!ok && headless && a.target.via === "auto" && config.routing.retryOnQuota && status.turns <= 1 && status.tools === 0 && isQuotaFailure(resultText)) {
@@ -3508,8 +3753,8 @@ async function executeCodexRun(a) {
 		});
 	}
 	env.PAI_WORKER_ID = wid;
-	const prompt = (worktree ? worktreeSystemPrompt(wid, worktree.branch, worktree.dir) + "\n\n" : "") + parsed.prompt;
-	const status = {
+	const prompt = (worktree ? worktreeSystemPrompt(wid, worktree.branch, worktree.dir, worktree.snapshot) + "\n\n" : "") + parsed.prompt;
+	let status = {
 		id: wid,
 		pid: process.pid,
 		label,
@@ -3538,7 +3783,8 @@ async function executeCodexRun(a) {
 		...worktree ? {
 			worktreeDir: worktree.dir,
 			branch: worktree.branch,
-			worktreeBase: worktree.base
+			worktreeBase: worktree.base,
+			worktreeSnapshot: worktree.snapshot
 		} : {},
 		...a.specPath ? { spec: a.specPath } : {}
 	};
@@ -3648,6 +3894,20 @@ async function executeCodexRun(a) {
 	status.rc = rc;
 	status.secs = secs;
 	status.last = shortText(report?.notes ?? finalText, 90) || (ok ? "done" : "failed");
+	if (report?.changed?.length) {
+		const verify = verifyReportChanges(report.changed, worktree?.dir ?? cwd, t0);
+		if (!verify.ok) {
+			status.reportValid = false;
+			const note = verifyFailNote(verify);
+			status.last = shortText(note, 90);
+			report.notes = report.notes ? `${report.notes} — ${note}` : note;
+			appendLedger(ledger, "REPORT-UNVERIFIED", {
+				id: wid,
+				failures: verify.failures.length,
+				paths: verify.failures.map((f) => f.path).slice(0, 5).join(",")
+			});
+		}
+	}
 	saveStatus(logDir, status);
 	appendLedger(ledger, "WORKER-END", {
 		id: wid,
@@ -3661,7 +3921,7 @@ async function executeCodexRun(a) {
 		tools: status.tools,
 		label
 	});
-	if (worktree) recordWorktree(logDir, status, worktree, ok);
+	if (worktree) status = recordWorktree(logDir, status, worktree, ok);
 	if (!a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, report, worktreeExtras(status));
 	const finalRc = rc !== 0 ? rc : ok ? 0 : 1;
 	if (status.parent && isWorkerId(logDir, status.parent)) try {
@@ -3814,5 +4074,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-export { contextLabel as A, setWorkerLabel as B, mergeWorker as C, UNLABELED as D, ledgerSummary as E, loadStatuses as F, describeMcp as G, longInlinePromptHint as H, newWorkerId as I, expandMcpNames as K, nowStamp as L, isChatPane as M, isLive as N, ageOf as O, loadStatus as P, ownsPid as R, discardWorker as S, appendLedger as T, parseRunnerArgs as U, waitForTerminalStatus as V, shortText as W, itermUuid as _, projectLaunchConfig as a, sessionTag as b, handoffFromInside as c, workerDepth as d, checkPaneForWorker as f, itermForClaudeSession as g, currentTabKey as h, usageContextTokens as i, contextPercent as j, alive as k, readInbox as l, openPaneForWorker as m, runWorker as n, parseWorkerReport as o, openFollowPane as p, testProvider as r, renderReport as s, printResult as t, sayToWorker as u, resolveSession as v, worktreesDir as w, workerInScope as x, sessionMapPath as y, saveStatus as z };
-//# sourceMappingURL=run-DLG25bzt.mjs.map
+export { contextLabel as A, saveStatus as B, mergeWorker as C, UNLABELED as D, ledgerSummary as E, loadStatus as F, shortText as G, waitForTerminalStatus as H, loadStatuses as I, describeMcp as K, newWorkerId as L, elapsedOf as M, isChatPane as N, ageOf as O, isLive as P, nowStamp as R, discardWorker as S, appendLedger as T, longInlinePromptHint as U, setWorkerLabel as V, parseRunnerArgs as W, itermUuid as _, projectLaunchConfig as a, sessionTag as b, handoffFromInside as c, workerDepth as d, checkPaneForWorker as f, itermForClaudeSession as g, currentTabKey as h, usageContextTokens as i, contextPercent as j, alive as k, readInbox as l, openPaneForWorker as m, runWorker as n, parseWorkerReport as o, openFollowPane as p, expandMcpNames as q, testProvider as r, renderReport as s, printResult as t, sayToWorker as u, resolveSession as v, worktreesDir as w, workerInScope as x, sessionMapPath as y, ownsPid as z };
+//# sourceMappingURL=run-CqRvXGjd.mjs.map