@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/src/runs/shared/worktree-cleanup-plan.ts

@@ -14,7 +14,7 @@ import type {
 	ParallelHandoffManifest,
 } from "../../shared/types.ts";
 import { getAgentDir } from "../../shared/utils.ts";
-import { isTerminalParallelHandoffChildStatus } from "./parallel-handoff.ts";
+import { isTerminalParallelHandoffChildStatus, readParallelHandoffManifest } from "./parallel-handoff.ts";
 import { MACHINE_DIFF_OPTIONS, validateWorktreePatchRepresentsCurrentWorktree } from "./worktree.ts";
 
 export const WORKTREE_CLEANUP_PLAN_VERSION = 1 as const;
@@ -72,6 +72,8 @@ export interface WorktreeCleanupPlan {
 
 export interface BuildWorktreeCleanupPlanInput {
 	repo: string;
+	/** Internal maintenance seam: inspect only these paths with the same safety predicates. */
+	candidatePaths?: string[];
 	handoffPath?: string;
 	/** Internal test and migration seam for explicitly supplied handoff records. */
 	handoffPaths?: string[];
@@ -99,6 +101,7 @@ interface GitWorktreeRecord {
 	head: string;
 	branch?: string;
 	prunable?: string;
+	locked?: boolean;
 }
 
 interface ManifestMetadataRecord {
@@ -194,16 +197,16 @@ function comparablePath(candidate: string): string {
 	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
-function samePath(left: string, right: string): boolean {
+export function samePath(left: string, right: string): boolean {
 	if (comparablePath(left) === comparablePath(right)) return true;
 	if (process.platform !== "win32") return false;
 	// Git for Windows and Node can spell the same temp directory with different
 	// drive/short-name aliases. The directory identity is the final bounded
 	// fallback; never accept aliases when the filesystem cannot prove identity.
 	try {
-		const leftStat = fs.statSync(left);
-		const rightStat = fs.statSync(right);
-		return leftStat.dev !== 0 && leftStat.ino !== 0 && leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
+		const leftStat = fs.statSync(left, { bigint: true });
+		const rightStat = fs.statSync(right, { bigint: true });
+		return leftStat.dev !== 0n && leftStat.ino !== 0n && leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
 	} catch {
 		return false;
 	}
@@ -239,7 +242,7 @@ function validatePlanId(planId: string): string {
 	return planId;
 }
 
-function resolveRepoRoot(repo: string): string {
+export function resolveCleanupRepoRoot(repo: string): string {
 	const requested = path.resolve(repo);
 	const toplevel = runGitChecked(requested, ["rev-parse", "--show-toplevel"]);
 	return realpathExisting(toplevel);
@@ -288,6 +291,7 @@ export function parseGitWorktreeList(raw: string): GitWorktreeRecord[] {
 		if (line.startsWith("HEAD ")) current.head = line.slice("HEAD ".length).trim();
 		else if (line.startsWith("branch refs/heads/")) current.branch = line.slice("branch refs/heads/".length).trim();
 		else if (line === "detached") delete current.branch;
+		else if (line === "locked" || line.startsWith("locked ")) current.locked = true;
 		else if (line.startsWith("prunable ")) current.prunable = line.slice("prunable ".length).trim();
 	}
 	flush();
@@ -300,6 +304,10 @@ function listGitWorktrees(repoRoot: string): GitWorktreeRecord[] {
 	return parseGitWorktreeList(result.stdout);
 }
 
+export function isRegisteredCleanupWorktree(repoRoot: string, candidate: string): boolean {
+	return listGitWorktrees(repoRoot).some((tree) => samePath(tree.path, candidate));
+}
+
 function readJsonFile(filePath: string): unknown {
 	return JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
 }
@@ -313,11 +321,11 @@ function readManifest(manifestPath: string): ManifestReadResult {
 		const stat = fs.lstatSync(manifestPath);
 		if (stat.isSymbolicLink() || !stat.isFile()) return { error: `parallel handoff manifest is not a regular file: ${manifestPath}` };
 		if (stat.size > MAX_METADATA_FILE_BYTES) return { error: `parallel handoff manifest exceeds the ${MAX_METADATA_FILE_BYTES}-byte limit: ${manifestPath}` };
-		const parsed = readJsonFile(manifestPath);
-		if (!isRecord(parsed) || parsed.version !== 1 || !Array.isArray(parsed.groups)) {
+		const parsed = readParallelHandoffManifest(manifestPath);
+		if (!parsed) {
 			return { error: `invalid parallel handoff manifest version or groups: ${manifestPath}` };
 		}
-		return { manifest: parsed as unknown as ParallelHandoffManifest };
+		return { manifest: parsed };
 	} catch (error) {
 		const code = error && typeof error === "object" && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
 		if (code === "ENOENT") return { error: `parallel handoff manifest not found: ${manifestPath}` };
@@ -423,11 +431,10 @@ function loadMetadata(input: BuildWorktreeCleanupPlanInput, repoRoot: string): {
 	const discovered = discoverHandoffPaths(repoRoot, input);
 	const records: ManifestMetadataRecord[] = [];
 	const warnings = [...discovered.warnings];
-	const explicitPath = input.handoffPath ? path.isAbsolute(input.handoffPath) ? path.resolve(input.handoffPath) : path.resolve(repoRoot, input.handoffPath) : undefined;
 	for (const manifestPath of discovered.paths) {
 		const result = readManifest(manifestPath);
 		if (!result.manifest) {
-			if (explicitPath && comparablePath(manifestPath) === comparablePath(explicitPath)) warnings.push(result.error!);
+			warnings.push(result.error!);
 			continue;
 		}
 		const manifestRoot = resolveExistingPath(manifestPath);
@@ -526,7 +533,7 @@ function buildEntryBase(input: {
 	metadata?: ManifestMetadataRecord;
 	targetHead: string;
 }): WorktreeCleanupPlanEntry {
-	const recordedBaseDir = path.dirname(input.path);
+	const recordedBaseDir = input.metadata?.task.recordedBaseDir;
 	const patchPath = input.metadata ? metadataPatchPath(input.metadata) : undefined;
 	return {
 		path: input.path,
@@ -544,7 +551,7 @@ function buildEntryBase(input: {
 			branch: input.branch,
 			...(input.git?.head ? { worktreeHead: input.git.head } : {}),
 			...(input.metadata?.group.baseCommit ? { baseCommit: input.metadata.group.baseCommit } : {}),
-			recordedBaseDir,
+			...(recordedBaseDir ? { recordedBaseDir } : {}),
 			targetRef: input.targetHead,
 		},
 	};
@@ -626,8 +633,14 @@ function buildManagedEntry(input: {
 	const extensionsDir = path.join(getAgentDir(), "extensions");
 	if (pathInside(extensionsDir, pathInspection.realpath)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is inside Pi extensions directory '${extensionsDir}'`);
 	if (input.containmentInvalid || !pathInside(baseDir, pathInspection.realpath, true)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside configured base directory '${baseDir}'`);
+	const recordedBaseDir = record.task.recordedBaseDir;
+	if (typeof recordedBaseDir !== "string" || !path.isAbsolute(recordedBaseDir)) return blockedEntry(entry, "unknown", "keep", "handoff metadata has no creation-time base directory proof");
+	// Compare the saved canonical string, without following a newly replaced ancestor.
+	const creationRelative = path.relative(recordedBaseDir, pathInspection.realpath);
+	if (!creationRelative || creationRelative === ".." || creationRelative.startsWith(`..${path.sep}`) || path.isAbsolute(creationRelative)) return blockedEntry(entry, "ineligible", "keep", `worktree real path is outside its creation-time recorded base directory '${recordedBaseDir}'`);
 
 	if (rootPath === comparablePath(pathInspection.realpath)) return blockedEntry(entry, "ineligible", "keep", "worktree is the repository root");
+	if (git.locked) return blockedEntry(entry, "ineligible", "keep", "Git worktree is locked");
 	if (!git.branch) return blockedEntry(entry, "unknown", "unknown", "detached worktrees have no metadata-recorded branch");
 	if (record.task.branch !== git.branch) return blockedEntry(entry, "unknown", "unknown", `metadata branch '${record.task.branch}' does not match Git branch '${git.branch}'`);
 	if (record.task.worktreeRemoved) return blockedEntry(entry, "stale", "unknown", "handoff metadata already records this worktree as removed");
@@ -646,6 +659,9 @@ function buildManagedEntry(input: {
 		return blockedEntry(entry, "ineligible", "keep", "metadata-recorded branch is checked out at the repository root");
 	}
 
+	const retainedSession = record.child.sessionPath ?? record.status?.steps?.[record.child.index]?.sessionFile ?? record.status?.sessionFile;
+	if (typeof retainedSession === "string" && retainedSession.trim()) return blockedEntry(entry, "ineligible", "keep", "retained child resume still has a recorded session dependency");
+
 	const runState = inspectRunState(record, input.now, foregroundRunOwnership);
 	if (runState.kind === "unknown") return blockedEntry(entry, "unknown", "unknown", runState.reason ?? "owning run state is unknown");
 	if (runState.kind === "active") return blockedEntry(entry, "active", "keep", runState.reason ?? "owning run is active");
@@ -668,6 +684,10 @@ function buildManagedEntry(input: {
 	entry.preconditions.statusDigest = status.digest;
 	if (status.output && status.output.trim()) return blockedEntry(entry, "dirty", "keep", "worktree has uncommitted or untracked changes");
 
+	const ignored = runGit(worktreePath, ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"]);
+	if (ignored.status !== 0) return blockedEntry(entry, "unknown", "unknown", `ignored-file inspection failed: ${gitFailure(ignored, "git ls-files")}`);
+	if (ignored.stdout) return blockedEntry(entry, "ineligible", "keep", "worktree contains ignored files; cleanup preserves them");
+
 	const diff = runGit(worktreePath, ["diff", "--quiet", ...MACHINE_DIFF_OPTIONS, resolvedBase.value, "--"]);
 	if (diff.status !== 0 && diff.status !== 1) return blockedEntry(entry, "unknown", "unknown", `git diff safety check failed: ${gitFailure(diff, "git diff")}`);
 	const ancestor = runGit(repoRoot, ["merge-base", "--is-ancestor", git.head, targetHead]);
@@ -704,7 +724,7 @@ function buildManagedEntry(input: {
 
 	entry.state = "safe";
 	entry.decision = "remove";
-	entry.willDeleteBranch = branchTipIsAncestor;
+	entry.willDeleteBranch = false;
 	entry.reasons.push("extension-owned metadata, terminal run, contained clean worktree, and local divergence checks passed");
 	if (!branchTipIsAncestor) entry.reasons.push("local branch tip is not an ancestor of target HEAD; future apply must retain the branch");
 	return entry;
@@ -723,7 +743,7 @@ function buildMissingMetadataEntry(input: { record: ManifestMetadataRecord; targ
 	return blockedEntry(entry, "stale", "unknown", "handoff metadata records a worktree that is not present in Git worktree state");
 }
 
-function contentPayload(plan: Omit<WorktreeCleanupPlan, "contentHash" | "planId" | "createdAt" | "expiresAt">): unknown {
+export function worktreeCleanupContentPayload(plan: Omit<WorktreeCleanupPlan, "contentHash" | "planId" | "createdAt" | "expiresAt">): unknown {
 	return {
 		version: plan.version,
 		repoRoot: plan.repoRoot,
@@ -741,7 +761,7 @@ function stableEntrySort(left: WorktreeCleanupPlanEntry, right: WorktreeCleanupP
 
 export function buildWorktreeCleanupPlan(input: BuildWorktreeCleanupPlanInput): WorktreeCleanupPlan {
 	if (typeof input.repo !== "string" || !input.repo.trim()) throw new Error("worktree cleanup plan requires a repository path");
-	const repoRoot = resolveRepoRoot(input.repo);
+	const repoRoot = resolveCleanupRepoRoot(input.repo);
 	const now = input.now ?? Date.now();
 	if (!Number.isFinite(now)) throw new Error("worktree cleanup plan timestamp must be finite");
 	const baseDir = resolveCleanupBaseDir(repoRoot, input.worktreeBaseDir);
@@ -762,6 +782,7 @@ export function buildWorktreeCleanupPlan(input: BuildWorktreeCleanupPlanInput):
 	const entries: WorktreeCleanupPlanEntry[] = [];
 	const matchedMetadataRecords = new Set<ManifestMetadataRecord>();
 	for (const git of linkedGit) {
+		if (input.candidatePaths && !input.candidatePaths.some((candidate) => samePath(candidate, git.path))) continue;
 		const records = metadataByPath.get(comparablePath(git.path)) ?? (git.branch
 			? metadata.records.filter((record) => record.task.branch === git.branch && samePath(metadataRecordPath(record), git.path))
 			: []);
@@ -807,7 +828,7 @@ export function buildWorktreeCleanupPlan(input: BuildWorktreeCleanupPlanInput):
 		pruneCandidates,
 		...(warnings.length ? { warnings: [...new Set(warnings)].sort() } : {}),
 	};
-	const contentHash = sha256(JSON.stringify(contentPayload(basePlan)));
+	const contentHash = sha256(JSON.stringify(worktreeCleanupContentPayload(basePlan)));
 	const planId = validatePlanId(input.planId ?? randomUUID());
 	return {
 		...basePlan,
@@ -837,7 +858,7 @@ function formatPlanEntry(entry: WorktreeCleanupPlanEntry): string {
 export function formatWorktreeCleanupPlan(created: CreatedWorktreeCleanupPlan): string {
 	const { plan, planPath } = created;
 	const removable = plan.entries.filter((entry) => entry.decision === "remove");
-	const branches = removable.filter((entry) => entry.willDeleteBranch === true);
+
 	const kept = plan.entries.filter((entry) => entry.decision === "keep");
 	const unknown = plan.entries.filter((entry) => entry.decision === "unknown");
 	const section = (title: string, entries: WorktreeCleanupPlanEntry[], empty: string): string[] => [
@@ -852,7 +873,7 @@ export function formatWorktreeCleanupPlan(created: CreatedWorktreeCleanupPlan):
 		"",
 		...section("Will remove", removable, "none"),
 		"",
-		...section("Will delete local branches", branches, "none (plan-only mode; no branch will be deleted)"),
+		"Local branches: all retained, including after apply.",
 		"",
 		...section("Will keep, with reasons", kept, "none"),
 		"",
@@ -864,6 +885,7 @@ export function formatWorktreeCleanupPlan(created: CreatedWorktreeCleanupPlan):
 		"",
 		`Plan saved: ${planPath}`,
 		"Plan-only mode: no worktrees or branches were removed.",
+		`Apply this reviewed plan: subagent({ action: "worktree.cleanup", mode: "apply", repo: ${JSON.stringify(plan.repoRoot)}, planId: ${JSON.stringify(plan.planId)} })`,
 	];
 	return lines.join("\n");
-}
+}

package/dist/extensions/pi-subagents/src/runs/shared/worktree-lock.ts

@@ -0,0 +1,29 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { tryLease } from "../../shared/file-lease.ts";
+
+export function withHandoffWriteLock<T>(manifestPath: string, action: () => T): T {
+	const requested = path.resolve(manifestPath);
+	fs.mkdirSync(path.dirname(requested), { recursive: true });
+	const absolute = path.join(fs.realpathSync.native(path.dirname(requested)), path.basename(requested));
+	const release = tryLease(`${absolute}.write-lock`);
+	if (!release) throw new Error(`Handoff is being updated or cleaned: ${absolute}. Retry after the current operation completes.`);
+	try { return action(); } finally { release(); }
+}
+
+export async function withRepositoryWorktreeLock<T>(repo: string, action: () => T | Promise<T>, options: { signal?: AbortSignal; waitMs?: number } = {}): Promise<T> {
+	const git = spawnSync("git", ["-C", repo, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf-8", windowsHide: true });
+	if (git.status !== 0) throw new Error(git.error?.message || git.stderr.trim() || "Cannot resolve Git common directory.");
+	const lockPath = path.join(fs.realpathSync(git.stdout.trim()), "pi-subagents-worktree.lock");
+	const deadline = Date.now() + (options.waitMs ?? 2_000);
+	while (true) {
+		options.signal?.throwIfAborted();
+		const release = tryLease(lockPath);
+		if (release) {
+			try { return await action(); } finally { release(); }
+		}
+		if (Date.now() >= deadline) throw new Error("Repository worktree maintenance is busy; retry later.");
+		await new Promise<void>((resolve) => setTimeout(resolve, 25));
+	}
+}

package/dist/extensions/pi-subagents/src/runs/shared/worktree-setup-command.ts

@@ -2,6 +2,26 @@ import { spawn } from "node:child_process";
 import { createOwnedProcessTreeController } from "../background/owned-process-tree.ts";
 import type { ProcessTreeTerminal } from "../../shared/types.ts";
 
+function terminateCommandTree(pid: number, controller: ReturnType<typeof createOwnedProcessTreeController>): Promise<ProcessTreeTerminal> {
+	if (process.platform !== "win32") return controller.terminate();
+	return new Promise((resolve) => {
+		let settled = false;
+		const fallback = () => {
+			if (settled) return;
+			settled = true;
+			void controller.terminate().then(resolve);
+		};
+		const cleanup = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+		cleanup.once("error", fallback);
+		cleanup.once("close", (status) => {
+			if (settled) return;
+			if (status !== 0) return fallback();
+			settled = true;
+			resolve({ state: "observed", mechanism: "windows-taskkill", pid, verifiedAt: Date.now() });
+		});
+	});
+}
+
 export interface SetupCommandOptions {
 	cwd?: string;
 	env?: NodeJS.ProcessEnv;
@@ -19,6 +39,7 @@ export interface SetupCommandOptions {
 
 export interface SetupCommandResult {
 	stdout: string;
+	stdoutBuffer: Buffer;
 	stderr: string;
 	status: number | null;
 	signal: NodeJS.Signals | null;
@@ -46,7 +67,7 @@ export async function runSetupCommand(
 	options: SetupCommandOptions,
 ): Promise<SetupCommandResult> {
 	const result: SetupCommandResult = {
-		stdout: "", stderr: "", status: null, signal: null, outputIncomplete: false,
+		stdout: "", stdoutBuffer: Buffer.alloc(0), stderr: "", status: null, signal: null, outputIncomplete: false,
 	};
 	const maxBuffer = options.maxBuffer ?? 1024 * 1024;
 	if (!Number.isSafeInteger(maxBuffer) || maxBuffer <= 0) throw new Error("Invalid setup command maxBuffer");
@@ -84,7 +105,8 @@ export async function runSetupCommand(
 	let directSettled = false;
 	const releaseUnknownIO = () => {
 		if (!directSettled || result.processTree?.state !== "unknown") return;
-		result.error ??= commandError("Worktree setup process tree settlement is unverified", "PROCESS_TREE_UNVERIFIED");
+		const detail = result.processTree.diagnostic ? `: ${result.processTree.diagnostic}` : "";
+		result.error = commandError(`Worktree setup process tree settlement is unverified${detail}`, "PROCESS_TREE_UNVERIFIED");
 		result.outputIncomplete = true;
 		// Only local I/O is released; unknown descendant ownership remains retained.
 		child.stdin.destroy();
@@ -101,7 +123,7 @@ export async function runSetupCommand(
 			releaseUnknownIO();
 			return;
 		}
-		termination = tree.terminate().then((proof) => {
+		termination = terminateCommandTree(result.pid!, tree).then((proof) => {
 			result.processTree = proof;
 			releaseUnknownIO();
 			return proof;
@@ -177,7 +199,8 @@ export async function runSetupCommand(
 		if (termination) result.processTree = await termination;
 		const cancelled = cancellation();
 		if (cancelled) fail(cancelled);
-		result.stdout = Buffer.concat(stdout).toString("utf8");
+		result.stdoutBuffer = Buffer.concat(stdout);
+		result.stdout = result.stdoutBuffer.toString("utf8");
 		result.stderr = Buffer.concat(stderr).toString("utf8");
 		return result;
 	} finally {

package/dist/extensions/pi-subagents/src/runs/shared/worktree.ts

@@ -18,7 +18,9 @@ const WORKTREE_NAMING_COMPONENT_MAX_BYTES = 96;
 const WORKTREE_NAMING_LABEL_MAX_BYTES = 256;
 const WORKTREE_NAMING_BRANCH_MAX_BYTES = 256;
 const WORKTREE_COMMAND_OUTPUT_MAX_BYTES = 128 * 1024;
-export const MACHINE_DIFF_OPTIONS = ["--no-color", "--no-ext-diff", "--no-textconv", "--default-prefix", "--line-prefix=", "--no-relative"] as const;
+const WORKTRUNK_COMMAND = process.platform === "win32" ? "git" : "wt";
+const WORKTRUNK_ARG_PREFIX = process.platform === "win32" ? ["wt"] : [];
+export const MACHINE_DIFF_OPTIONS = ["--no-color", "--no-ext-diff", "--no-textconv", "--src-prefix=a/", "--dst-prefix=b/", "--line-prefix=", "--no-relative"] as const;
 const MACHINE_PATCH_OPTIONS = [...MACHINE_DIFF_OPTIONS, "--binary"] as const;
 const PATCH_VALIDATION_OPTIONS = ["apply", "--check", "--cached", "--reverse", "--binary", "--whitespace=nowarn"] as const;
 
@@ -55,6 +57,8 @@ export interface WorktreeSetup {
 }
 
 export interface WorktreeInfo {
+	/** Canonical parent captured at allocation; never re-resolve this evidence later. */
+	recordedBaseDir?: string;
 	path: string;
 	agentCwd: string;
 	branch: string;
@@ -78,6 +82,7 @@ export interface WorktreeDiff {
 }
 
 export interface WorktreeCleanupTask {
+	recordedBaseDir?: string;
 	index: number;
 	path: string;
 	branch: string;
@@ -178,7 +183,7 @@ export interface WorktreeSetupProgress {
 	setup: WorktreeSetup;
 	attempts: Array<{ index: number; branch: string; path?: string; validated: boolean; command?: WorktreeSetupProgress["command"]; hookCommand?: WorktreeSetupProgress["command"] }>;
 	phase: string;
-	command?: { command: string; args: string[]; pid?: number; processGroupId?: number; result?: Omit<SetupCommandResult, "stdout" | "stderr"> };
+	command?: { command: string; args: string[]; pid?: number; processGroupId?: number; result?: Omit<SetupCommandResult, "stdout" | "stdoutBuffer" | "stderr"> };
 	unknown?: string;
 	cleanup?: WorktreeCleanupReport;
 }
@@ -243,7 +248,7 @@ class SetupTransaction {
 			...options, signal: this.options.signal, deadlineAt: this.options.deadlineAt,
 			onSpawn: (process) => { Object.assign(this.progress.command!, process); this.publish(); },
 		});
-		const { stdout: _stdout, stderr: _stderr, ...metadata } = result;
+		const { stdout: _stdout, stdoutBuffer: _stdoutBuffer, stderr: _stderr, ...metadata } = result;
 		this.progress.command.result = metadata;
 		if (result.processTree?.state === "unknown") this.unknown(result.error ?? "Command tree settlement unverified");
 		this.publish();
@@ -339,11 +344,9 @@ export function validateWorktreePatchRepresentsCurrentWorktree(worktreePath: str
 	return undefined;
 }
 
-async function resolveRepoState(tx: SetupTransaction, cwd: string, requestedBaseRef: string | undefined): Promise<RepoState> {
+async function probeWorktreeSource(tx: Pick<SetupTransaction, "git" | "gitChecked">, cwd: string): Promise<string> {
 	const repoCheck = await tx.git(cwd, ["rev-parse", "--is-inside-work-tree"], [0, 128]);
 	if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") throw new Error("worktree isolation requires a git repository");
-	const rawPrefix = (await tx.gitChecked(cwd, ["rev-parse", "--show-prefix"])).trim();
-	const cwdRelative = rawPrefix ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
 	const toplevel = (await tx.gitChecked(cwd, ["rev-parse", "--show-toplevel"])).trim();
 
 	// pi-subagents writes durable runtime state under .pi-subagents/ by default;
@@ -352,6 +355,26 @@ async function resolveRepoState(tx: SetupTransaction, cwd: string, requestedBase
 	if (status.trim().length > 0) {
 		throw new Error("worktree isolation requires a clean git working tree. Commit or stash changes first.");
 	}
+	return toplevel;
+}
+
+/** Read-only admission check; allocation repeats it because source state can change. */
+export async function preflightWorktreeSource(cwd: string, options: Pick<SetupCommandOptions, "signal" | "deadlineAt"> = {}): Promise<void> {
+	const git = async (cwd: string, args: string[], acceptedExitCodes: readonly number[] = [0]): Promise<SetupCommandResult> => {
+		const result = await runSetupCommand("git", ["-C", cwd, ...args], { ...options, acceptedExitCodes });
+		if (result.error) throw result.error;
+		if (result.outputIncomplete || result.status === null || !acceptedExitCodes.includes(result.status)) {
+			throw new Error(result.stderr.trim().slice(0, 2000) || "Worktree source probe failed");
+		}
+		return result;
+	};
+	await probeWorktreeSource({ git, gitChecked: async (cwd, args) => (await git(cwd, args)).stdout }, cwd);
+}
+
+async function resolveRepoState(tx: SetupTransaction, cwd: string, requestedBaseRef: string | undefined): Promise<RepoState> {
+	const toplevel = await probeWorktreeSource(tx, cwd);
+	const rawPrefix = (await tx.gitChecked(cwd, ["rev-parse", "--show-prefix"])).trim();
+	const cwdRelative = rawPrefix ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
 
 	const baseRef = normalizeWorktreeBaseRef(requestedBaseRef) ?? DEFAULT_WORKTREE_BASE_REF;
 	let baseCommit: string;
@@ -419,9 +442,14 @@ function shortWorktreeHash(value: string): string {
 }
 
 function truncateUtf8(value: string, maxBytes: number): string {
-	if (Buffer.byteLength(value, "utf-8") <= maxBytes) return value;
-	const truncated = Buffer.from(value, "utf-8").subarray(0, maxBytes).toString("utf-8");
-	return /[\uD800-\uDFFF]$/u.test(truncated) ? truncated.slice(0, -1) : truncated;
+	const bytes = Buffer.from(value, "utf-8");
+	if (bytes.length <= maxBytes) return value;
+	// Back off to a code-point boundary before decoding: cutting mid-sequence
+	// emits U+FFFD (3 bytes per dangling byte), which can push the re-encoded
+	// result beyond maxBytes (e.g. a 256-byte cap yields a 258-byte string).
+	let end = maxBytes;
+	while (end > 0 && (bytes[end]! & 0xc0) === 0x80) end -= 1;
+	return bytes.subarray(0, end).toString("utf-8");
 }
 
 /** Convert an arbitrary label to a single safe filesystem/branch component. */
@@ -526,6 +554,11 @@ function hasConfiguredWorktreeBaseDir(baseDir: string | undefined): boolean {
 		: (process.env.SELESAI_SUBAGENTS_WORKTREE_DIR?.trim().length ?? 0) > 0;
 }
 
+function isInsidePiExtensionsDirectory(targetPath: string): boolean {
+	const extensionsDir = normalizeComparableCwd(path.join(getAgentDir(), "extensions"));
+	return isPathInside(extensionsDir, normalizeComparableCwd(targetPath));
+}
+
 interface WorktrunkCapability {
 	available: boolean;
 	reason?: string;
@@ -533,7 +566,7 @@ interface WorktrunkCapability {
 
 function runWorktrunk(args: string[], cwd?: string): WorktreeCommandResult {
 	try {
-		const result = spawnSync("wt", args, {
+		const result = spawnSync(WORKTRUNK_COMMAND, [...WORKTRUNK_ARG_PREFIX, ...args], {
 			cwd,
 			encoding: "utf-8",
 			windowsHide: true,
@@ -578,7 +611,7 @@ export function resolveWorktreeProvider(requested: WorktreeProvider | undefined,
 	return "native";
 }
 
-async function resolveSetupProvider(tx: SetupTransaction, requested: WorktreeProvider | undefined, baseDir?: string): Promise<ManagedWorktreeProvider> {
+async function resolveSetupProvider(tx: SetupTransaction, requested: WorktreeProvider | undefined, baseDir: string | undefined, repoRoot: string): Promise<ManagedWorktreeProvider> {
 	const selection = requested ?? DEFAULT_WORKTREE_PROVIDER;
 	if (selection !== "auto" && selection !== "native" && selection !== "worktrunk") throw new Error('worktree provider must be "auto", "native", or "worktrunk"');
 	if (selection === "native") return "native";
@@ -586,13 +619,14 @@ async function resolveSetupProvider(tx: SetupTransaction, requested: WorktreePro
 		if (selection === "worktrunk") throw new Error("worktreeProvider='worktrunk' cannot be combined with worktreeBaseDir or SELESAI_SUBAGENTS_WORKTREE_DIR");
 		return "native";
 	}
+	if (selection === "auto" && isInsidePiExtensionsDirectory(repoRoot)) return "native";
 	let reason: string | undefined;
 	try {
 		const probeExitCodes = Array.from({ length: 256 }, (_, code) => code);
-		const version = await tx.command("wt", ["--version"], { maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES, acceptedExitCodes: probeExitCodes });
+		const version = await tx.command(WORKTRUNK_COMMAND, [...WORKTRUNK_ARG_PREFIX, "--version"], { maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES, acceptedExitCodes: probeExitCodes });
 		if (version.status !== 0 || !/\b(?:wt\s+)?v?(\d+\.\d+(?:\.\d+)?)\b/i.test(version.stdout.trim())) reason = "Worktrunk is unavailable or returned an invalid version";
 		else {
-			const help = await tx.command("wt", ["switch", "--help"], { maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES, acceptedExitCodes: probeExitCodes });
+			const help = await tx.command(WORKTRUNK_COMMAND, [...WORKTRUNK_ARG_PREFIX, "switch", "--help"], { maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES, acceptedExitCodes: probeExitCodes });
 			const missing = ["--create", "--base", "--no-cd", "--no-hooks", "--format"].filter((flag) => !`${help.stdout}\n${help.stderr}`.includes(flag));
 			if (help.status !== 0 || missing.length) reason = `Worktrunk switch capability unavailable: ${missing.join(", ")}`;
 		}
@@ -616,11 +650,13 @@ export function shouldDeferWorktreeCwd(requested: WorktreeProvider | undefined,
  * to the repository. Managed leaves always nest one level deeper under the
  * project folder (`basename(repoRoot)`).
  */
-function resolveWorktreeDedicatedRoot(configuredBaseDir: string | undefined, repoRoot: string): string {
+function resolveWorktreeDedicatedRoot(configuredBaseDir: string | undefined, repoRoot: string, relocateExtensionRepo = true): string {
 	const rawBaseDir = configuredBaseDir ?? process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;
 	let expanded: string;
 	if (rawBaseDir === undefined || (configuredBaseDir === undefined && !rawBaseDir.trim())) {
-		expanded = path.join(path.dirname(repoRoot), "worktrees");
+		expanded = relocateExtensionRepo && isInsidePiExtensionsDirectory(repoRoot)
+			? path.join(getAgentDir(), "worktrees")
+			: path.join(path.dirname(repoRoot), "worktrees");
 	} else {
 		const trimmed = rawBaseDir.trim();
 		if (!trimmed) throw new Error("worktree base directory cannot be empty");
@@ -715,13 +751,35 @@ export function resolveExpectedWorktreeAgentCwd(cwd: string, runId: string, inde
 function linkNodeModulesIfPresent(toplevel: string, worktreePath: string): boolean {
 	const nodeModulesPath = path.join(toplevel, "node_modules");
 	const nodeModulesLinkPath = path.join(worktreePath, "node_modules");
-	if (!fs.existsSync(nodeModulesPath) || fs.existsSync(nodeModulesLinkPath)) return false;
+	const hasDirectoryEntry = (candidate: string): boolean => {
+		try { fs.lstatSync(candidate); return true; }
+		catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+			throw error;
+		}
+	};
 	try {
-		fs.symlinkSync(nodeModulesPath, nodeModulesLinkPath);
+		if (hasDirectoryEntry(nodeModulesLinkPath)) return false;
+		let sourceRealPath: string;
+		try {
+			if (!fs.statSync(nodeModulesPath).isDirectory()) throw new Error("source node_modules is not a directory");
+			sourceRealPath = fs.realpathSync.native(nodeModulesPath);
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+			throw error;
+		}
+		fs.symlinkSync(nodeModulesPath, nodeModulesLinkPath, process.platform === "win32" ? "junction" : "dir");
+		if (!fs.lstatSync(nodeModulesLinkPath).isSymbolicLink()
+			|| fs.realpathSync.native(nodeModulesLinkPath) !== sourceRealPath) {
+			throw new Error("created link does not resolve to the source node_modules");
+		}
 		return true;
-	} catch {
-		// Symlink creation is optional (e.g., unsupported filesystems on CI runners).
-		return false;
+	} catch (error) {
+		const code = error instanceof Error && "code" in error && typeof error.code === "string" ? `${error.code}: ` : "";
+		throw new Error(
+			`failed to link node_modules from ${nodeModulesPath} to ${nodeModulesLinkPath}: ${code}${error instanceof Error ? error.message : String(error)}`,
+			{ cause: error },
+		);
 	}
 }
 
@@ -890,9 +948,11 @@ async function createNativeWorktree(
 	if (branch.status !== 1 || pathExists) throw new Error(`worktree path or branch already exists: ${worktreePath}, ${naming.requestedBranch}`);
 	tx.attempt(index, naming.requestedBranch, worktreePath);
 	ensureProjectWorktreeDir(dedicatedRoot, toplevel);
+	const recordedBaseDir = normalizeComparableCwd(path.dirname(worktreePath));
 	await tx.git(toplevel, ["worktree", "add", worktreePath, "-b", naming.requestedBranch, baseCommit]);
 	const worktree: WorktreeInfo = {
 		path: worktreePath,
+		recordedBaseDir,
 		agentCwd: worktreePath,
 		branch: naming.requestedBranch,
 		index,
@@ -942,7 +1002,7 @@ async function createWorktrunkWorktree(
 	const naming = buildWorktreeNaming({ runId, index, agent: agents?.[index], label: labels?.[index], task: tasks?.[index], branchPrefix });
 	const args = ["-C", toplevel, "switch", "--create", naming.requestedBranch, "--base", baseCommit, "--no-cd", "--no-hooks", "--format", "json"];
 	tx.attempt(index, naming.requestedBranch);
-	const result = await tx.command("wt", args, { cwd: toplevel, maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES });
+	const result = await tx.command(WORKTRUNK_COMMAND, [...WORKTRUNK_ARG_PREFIX, ...args], { cwd: toplevel, maxBuffer: WORKTREE_COMMAND_OUTPUT_MAX_BYTES });
 	tx.progress.phase = "validation";
 	try {
 		const output = parseWorktrunkSwitchOutput(result.stdout);
@@ -971,6 +1031,7 @@ async function createWorktrunkWorktree(
 		if (returnedHead !== baseCommit) throw new Error("Worktrunk provisioning returned a worktree at a different base commit");
 		const worktree: WorktreeInfo = {
 			path: worktreePath,
+			recordedBaseDir: normalizeComparableCwd(path.dirname(worktreePath)),
 			agentCwd: cwdRelative ? path.join(worktreePath, cwdRelative) : worktreePath,
 			branch: naming.requestedBranch,
 			index,
@@ -1134,6 +1195,7 @@ function cleanupSingleWorktree(
 			branch: worktree.branch,
 			...(worktree.provider ? { provider: worktree.provider } : {}),
 			...(worktree.naming ? { naming: worktree.naming } : {}),
+			...(worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {}),
 			worktreeRemoved: false,
 			branchRemoved: false,
 			preserved: true,
@@ -1158,6 +1220,7 @@ function cleanupSingleWorktree(
 				branch: worktree.branch,
 				...(worktree.provider ? { provider: worktree.provider } : {}),
 				...(worktree.naming ? { naming: worktree.naming } : {}),
+				...(worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {}),
 				worktreeRemoved: false,
 				branchRemoved: false,
 				preserved: true,
@@ -1193,6 +1256,7 @@ function cleanupSingleWorktree(
 					branch: worktree.branch,
 					...(worktree.provider ? { provider: worktree.provider } : {}),
 					...(worktree.naming ? { naming: worktree.naming } : {}),
+					...(worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {}),
 					worktreeRemoved: false,
 					branchRemoved: false,
 					preserved: true,
@@ -1214,6 +1278,7 @@ function cleanupSingleWorktree(
 					branch: worktree.branch,
 					...(worktree.provider ? { provider: worktree.provider } : {}),
 					...(worktree.naming ? { naming: worktree.naming } : {}),
+					...(worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {}),
 					worktreeRemoved: false,
 					branchRemoved: false,
 					preserved: true,
@@ -1243,6 +1308,7 @@ function cleanupSingleWorktree(
 		branch: worktree.branch,
 		...(worktree.provider ? { provider: worktree.provider } : {}),
 		...(worktree.naming ? { naming: worktree.naming } : {}),
+		...(worktree.recordedBaseDir ? { recordedBaseDir: worktree.recordedBaseDir } : {}),
 		worktreeRemoved,
 		branchRemoved,
 		...(errors.length ? { errors } : {}),
@@ -1267,7 +1333,7 @@ async function compensateSetup(tx: SetupTransaction): Promise<WorktreeCleanupRep
 			deadlineAt: tx.options.deadlineAt, acceptedExitCodes,
 			onSpawn: (process) => { Object.assign(tx.progress.command!, process); tx.publish(); },
 		});
-		const { stdout: _stdout, stderr: _stderr, ...metadata } = result;
+		const { stdout: _stdout, stdoutBuffer: _stdoutBuffer, stderr: _stderr, ...metadata } = result;
 		tx.progress.command.result = metadata;
 		if (result.processTree?.state === "unknown") tx.unknown(result.error ?? "Rollback command settlement unverified");
 		tx.publish();
@@ -1282,7 +1348,7 @@ async function compensateSetup(tx: SetupTransaction): Promise<WorktreeCleanupRep
 		}
 		const known = setup.worktrees.find((worktree) => worktree.index === attempt.index);
 		const task: WorktreeCleanupTask = { index: attempt.index, path: attempt.path, branch: attempt.branch,
-			provider: known?.provider ?? "native", naming: known?.naming, worktreeRemoved: false, branchRemoved: false };
+			provider: known?.provider ?? "native", naming: known?.naming, recordedBaseDir: known?.recordedBaseDir, worktreeRemoved: false, branchRemoved: false };
 		report.tasks.push(task);
 		try {
 			if (normalizeComparableCwd(attempt.path) === normalizeComparableCwd(setup.cwd)) throw new Error("Refusing source-checkout removal");
@@ -1331,9 +1397,11 @@ async function allocateWorktrees(tx: SetupTransaction, cwd: string, runId: strin
 	tx.progress.setup.cwd = repo.toplevel;
 	tx.progress.setup.baseCommit = repo.baseCommit;
 	const setupHook = resolveWorktreeSetupHook(repo.toplevel, options?.setupHook);
-	const provider = await resolveSetupProvider(tx, options?.provider, options?.baseDir);
+	const provider = await resolveSetupProvider(tx, options?.provider, options?.baseDir, repo.toplevel);
 	const branchPrefix = normalizeWorktreeBranchPrefix(options?.branchPrefix);
-	const dedicatedRoot = provider === "native" ? resolveWorktreeDedicatedRoot(options?.baseDir, repo.toplevel) : undefined;
+	const dedicatedRoot = provider === "native"
+		? resolveWorktreeDedicatedRoot(options?.baseDir, repo.toplevel, (options?.provider ?? DEFAULT_WORKTREE_PROVIDER) === "auto")
+		: undefined;
 	const worktrees = tx.progress.setup.worktrees;
 
 	try {
@@ -1483,4 +1551,4 @@ export function formatWorktreeDiffSummary(diffs: WorktreeDiff[]): string {
 	const patchesDir = path.dirname(changed[0]!.patchPath);
 	lines.push(`Full patches: ${patchesDir}`);
 	return lines.join("\n").trimEnd();
-}
+}