@agimon-ai/po-git 0.0.0-alpha.7 → 0.0.0-alpha.71

package/dist/{worktreeOperations-DGUbUnYU.cjs → worktreeOperations-CD7s0YnO.cjs}

@@ -21,13 +21,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_child_process = require("node:child_process");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
 let node_crypto = require("node:crypto");
-let node_os = require("node:os");
-node_os = __toESM(node_os, 1);
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let js_yaml = require("js-yaml");
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
 let node_util = require("node:util");
 let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
 let node_timers_promises = require("node:timers/promises");
@@ -44,7 +45,7 @@ let node_timers_promises = require("node:timers/promises");
 */
 const READ_TIMEOUT_MS = 3e4;
 const ADD_TIMEOUT_MS = 3e5;
-const REMOVE_TIMEOUT_MS = 3e5;
+const REMOVE_TIMEOUT_MS$1 = 3e5;
 const PRUNE_TIMEOUT_MS = 15e3;
 /** fetch and push: bounded by the network, so long enough for a slow link, short enough to notice a dead one. */
 const NETWORK_TIMEOUT_MS = 12e4;
@@ -197,9 +198,9 @@ function createWorktreeGit() {
 				"remove",
 				...force ? ["--force"] : [],
 				path
-			], REMOVE_TIMEOUT_MS);
+			], REMOVE_TIMEOUT_MS$1);
 			if (result.code === 0) return;
-			if (missingWorktree(result.stderr) && !node_fs.default.existsSync(path)) {
+			if (missingWorktree(result.stderr) && !await node_fs_promises.default.access(path).then(() => true, () => false)) {
 				await prune(repositoryRoot);
 				return;
 			}
@@ -285,6 +286,25 @@ function createWorktreeGit() {
 	};
 }
 //#endregion
+//#region src/constants/git.ts
+/** Workspace-mounted routes behind the new-session dialog. */
+const GIT_BRANCHES_PATH = "/branches";
+const GIT_SESSIONS_PATH = "/sessions";
+/** Workspace-mounted: that workspace's remote auth for manual pull, push and rebase. */
+const GIT_AUTH_PATH = "/auth";
+/** Session-mounted: the session's change against its base, and one file's hunks. */
+const GIT_REVIEW_PATH = "/review";
+const GIT_REVIEW_FILE_PATH = "/review/file";
+/** Repository file, relative to the checkout root, whose `setup` commands run in every new worktree. */
+const WORKTREE_CONFIG_FILE = ".po/worktree.yaml";
+/**
+* po-runner's session command, so setup runs as a runner of the worktree session and its log
+* shows in Runners. Mirrors po-runner's `runnerLaunchLine`; the command follows the separator.
+*/
+const WORKTREE_SETUP_LAUNCH = "/runners start name=worktree-setup --";
+/** Installs the rift CLI. Shown to the person to copy, and named in the error an agent reads. */
+const RIFT_INSTALL_COMMAND = "npm install -g rift-snapshot";
+//#endregion
 //#region src/services/errors/index.ts
 var PoGitExpectedError = class extends Error {
 	code;
@@ -320,12 +340,12 @@ const OWNER_ONLY_FILE = 384;
 * record in it. Writing beside the target and renaming makes the swap atomic on
 * the same filesystem, so a reader sees either the old file or the new one.
 */
-function writeJsonAtomic(file, value) {
+async function writeJsonAtomic(file, value) {
 	const directory = node_path.default.dirname(file);
-	node_fs.default.mkdirSync(directory, { recursive: true });
-	const temporary = node_path.default.join(directory, `.${node_path.default.basename(file)}.${String(process.pid)}.tmp`);
-	node_fs.default.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
-	node_fs.default.renameSync(temporary, file);
+	await node_fs_promises.default.mkdir(directory, { recursive: true });
+	const temporary = node_path.default.join(directory, `.${node_path.default.basename(file)}.${(0, node_crypto.randomUUID)()}.tmp`);
+	await node_fs_promises.default.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
+	await node_fs_promises.default.rename(temporary, file);
 }
 /**
 * Reads JSON, treating every failure as absent.
@@ -334,9 +354,9 @@ function writeJsonAtomic(file, value) {
 * here: there is nothing to act on. Distinguishing them would only offer a
 * choice no caller wants to make.
 */
-function readJson(file) {
+async function readJson(file) {
 	try {
-		return JSON.parse(node_fs.default.readFileSync(file, "utf8"));
+		return JSON.parse(await node_fs_promises.default.readFile(file, "utf8"));
 	} catch {
 		return;
 	}
@@ -355,12 +375,12 @@ const MAX_LABEL_LENGTH = 32;
 * the registry is per repository and must be found from inside a worktree too.
 * A session may run in a subdirectory, so the nearest enclosing checkout is used.
 */
-function gitCommonDirectory(directory) {
+async function gitCommonDirectory(directory) {
 	let root = node_path.default.resolve(directory);
 	let marker = node_path.default.join(root, ".git");
 	let stat;
 	for (;;) try {
-		stat = node_fs.default.statSync(marker);
+		stat = await node_fs_promises.default.stat(marker);
 		break;
 	} catch {
 		const parent = node_path.default.dirname(root);
@@ -371,14 +391,14 @@ function gitCommonDirectory(directory) {
 	if (stat.isDirectory()) return marker;
 	let pointer;
 	try {
-		pointer = node_fs.default.readFileSync(marker, "utf8").trim();
+		pointer = (await node_fs_promises.default.readFile(marker, "utf8")).trim();
 	} catch {
 		return;
 	}
 	if (!pointer.startsWith("gitdir:")) return void 0;
 	const gitDir = node_path.default.resolve(root, pointer.slice(7).trim());
 	try {
-		const common = node_fs.default.readFileSync(node_path.default.join(gitDir, "commondir"), "utf8").trim();
+		const common = (await node_fs_promises.default.readFile(node_path.default.join(gitDir, "commondir"), "utf8")).trim();
 		return node_path.default.resolve(gitDir, common);
 	} catch {
 		return gitDir;
@@ -397,8 +417,8 @@ function repositoryLabel(root) {
 * registry. Falling back to the path keeps a non-repository directory usable
 * instead of failing, though nothing here should reach that case.
 */
-function repositoryId(root) {
-	const common = gitCommonDirectory(root);
+async function repositoryId(root) {
+	const common = await gitCommonDirectory(root);
 	const token = common === void 0 ? `root:${node_path.default.resolve(root)}` : `git:${common}`;
 	return (0, node_crypto.createHash)("sha256").update(token).digest("hex").slice(0, ID_LENGTH);
 }
@@ -434,22 +454,26 @@ function credentialsFile(homeDir = node_os.default.homedir()) {
 	return node_path.default.join(poGitRoot(homeDir), "credentials.json");
 }
 /** One registry file per repository, keyed by the shared git directory. */
-function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
-	const id = repositoryId(repositoryRoot);
+async function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
+	const id = await repositoryId(repositoryRoot);
 	const root = node_path.default.join(poGitRoot(homeDir), "registry");
 	const canonical = node_path.default.join(root, id, "worktrees.json");
-	if (node_fs.default.existsSync(canonical)) return canonical;
+	if (await node_fs_promises.default.access(canonical).then(() => true, () => false)) return canonical;
 	let names;
 	try {
-		names = node_fs.default.readdirSync(root);
+		names = await node_fs_promises.default.readdir(root);
 	} catch {
 		return canonical;
 	}
-	const legacyFiles = names.filter((entry) => entry.endsWith(`--${id}`)).sort().map((entry) => node_path.default.join(root, entry, "worktrees.json")).filter((file) => node_fs.default.existsSync(file));
+	const legacyFiles = [];
+	for (const entry of names.filter((name) => name.endsWith(`--${id}`)).sort()) {
+		const file = node_path.default.join(root, entry, "worktrees.json");
+		if (await node_fs_promises.default.access(file).then(() => true, () => false)) legacyFiles.push(file);
+	}
 	if (legacyFiles.length === 0) return canonical;
 	const entries = /* @__PURE__ */ new Map();
 	for (const file of legacyFiles) {
-		const legacy = readJson(file);
+		const legacy = await readJson(file);
 		if (legacy?.version !== 1 || !Array.isArray(legacy.entries)) continue;
 		for (const value of legacy.entries) {
 			if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || value.id === "") continue;
@@ -460,20 +484,119 @@ function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
 		}
 	}
 	const temporary = `${canonical}.${(0, node_crypto.randomUUID)()}.migration`;
-	writeJsonAtomic(temporary, {
+	await writeJsonAtomic(temporary, {
 		version: 1,
 		entries: [...entries.values()]
 	});
 	try {
-		node_fs.default.linkSync(temporary, canonical);
+		await node_fs_promises.default.link(temporary, canonical);
 	} catch (error) {
 		if (error.code !== "EEXIST") throw error;
 	} finally {
-		node_fs.default.rmSync(temporary);
+		await node_fs_promises.default.rm(temporary);
 	}
 	return canonical;
 }
 //#endregion
+//#region src/services/riftCli/index.ts
+/** Present at a repository root, it makes worktrees Rift copy-on-write workspaces instead of git worktrees. */
+const RIFT_CONFIG_FILE = ".rift.toml";
+/** Rift's identity marker; a root without it was never `rift init`ed. */
+const RIFT_MARKER = ".rift";
+/** Cloning is instant, but `.rift.toml` hooks such as an install run inside create. */
+const CREATE_TIMEOUT_MS = 6e5;
+const REMOVE_TIMEOUT_MS = 3e5;
+/**
+* Runs the rift CLI. Stderr is dropped rather than piped: hooks inherit it and may keep it open
+* after rift exits (a `docker compose up -d`), and raw output never reaches a tool result anyway.
+*/
+function rift(cwd, args, timeout) {
+	return new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)("rift", [...args], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout
+		});
+		let stdout = "";
+		child.stdout.on("data", (chunk) => stdout += String(chunk));
+		child.on("error", (error) => reject(error.code === "ENOENT" ? new PoGitExpectedError("rift_missing", `This repository has ${RIFT_CONFIG_FILE}, but the rift CLI is not installed.`, false, `Install it with \`${RIFT_INSTALL_COMMAND}\`, run \`rift init\` in the repository root, then try again. An agent asks the person with ask_user_question before installing. Removing ${RIFT_CONFIG_FILE} falls back to git worktrees.`) : error));
+		child.on("exit", (code) => resolve({
+			code: code ?? 1,
+			stdout
+		}));
+	});
+}
+const exists = (file) => node_fs_promises.default.access(file).then(() => true, () => false);
+function createWorktreeRift() {
+	const remove = async (target) => {
+		if (!await exists(target)) return;
+		const result = await rift(node_path.default.dirname(target), ["remove", target], REMOVE_TIMEOUT_MS);
+		if (result.code !== 0) throw new Error(`rift remove failed (exit ${String(result.code)})`);
+	};
+	return {
+		enabled: (repositoryRoot) => exists(node_path.default.join(repositoryRoot, RIFT_CONFIG_FILE)),
+		async create({ repositoryRoot, path: target, branch, baseRef, existing, remote }) {
+			if (!await exists(node_path.default.join(repositoryRoot, RIFT_MARKER))) {
+				await rift(repositoryRoot, ["--help"], READ_TIMEOUT_MS);
+				throw new PoGitExpectedError("invalid_request", `This repository has ${RIFT_CONFIG_FILE}, but Rift is not initialized for ${repositoryRoot}.`, false, "Run `rift init` in the repository root (not inside a git worktree), then try again.");
+			}
+			if (await exists(target)) throw new Error(`The worktree path ${target} already exists.`);
+			await node_fs_promises.default.mkdir(node_path.default.dirname(target), { recursive: true });
+			const created = await rift(repositoryRoot, [
+				"create",
+				repositoryRoot,
+				"--into",
+				node_path.default.dirname(target),
+				"--name",
+				node_path.default.basename(target),
+				"--copy-all"
+			], CREATE_TIMEOUT_MS);
+			if (created.code !== 0) {
+				await remove(target).catch(() => void 0);
+				throw new Error(`rift create failed (exit ${String(created.code)})`);
+			}
+			const switchArgs = existing ? remote === void 0 ? [
+				"switch",
+				"--discard-changes",
+				branch
+			] : [
+				"switch",
+				"--discard-changes",
+				"--track",
+				"-c",
+				branch,
+				`${remote}/${branch}`
+			] : [
+				"switch",
+				"--discard-changes",
+				"-c",
+				branch,
+				baseRef
+			];
+			for (const args of [switchArgs, ["clean", "-fd"]]) {
+				const result = await runGit(target, args, { timeout: READ_TIMEOUT_MS });
+				if (result.code !== 0) {
+					await remove(target).catch(() => void 0);
+					throw new Error(`git ${String(args[0])} in the rift failed (exit ${String(result.code)})`);
+				}
+			}
+		},
+		remove,
+		async fetchBranch({ repositoryRoot, path: source, branch }) {
+			const result = await runGit(repositoryRoot, [
+				"fetch",
+				source,
+				`refs/heads/${branch}:refs/heads/${branch}`
+			], { timeout: READ_TIMEOUT_MS });
+			if (result.code !== 0) throw new Error(`git fetch from the rift failed (exit ${String(result.code)})`);
+		}
+	};
+}
+//#endregion
 //#region src/services/worktreeEvents/index.ts
 const GIT_WORKTREE_LIFECYCLE_EVENT = "git_worktree_lifecycle";
 const GIT_WORKTREE_MESSAGE_EVENT = "git_worktree_message";
@@ -588,18 +711,22 @@ function refuseClose(input) {
 * uncommitted work, so losing the record would lose the only pointer to it.
 * Deletion is always a separate, named decision.
 */
-function reconcile(records, probe) {
+async function reconcile(records, probe) {
 	const changed = [];
+	const next = [];
+	for (const record of records) {
+		if (record.status === "orphaned" || await probe.exists(record.path) && probe.alive(record)) {
+			next.push(record);
+			continue;
+		}
+		changed.push(record.id);
+		next.push({
+			...record,
+			status: "orphaned"
+		});
+	}
 	return {
-		records: records.map((record) => {
-			if (record.status === "orphaned") return record;
-			if (!(!probe.exists(record.path) || !probe.alive(record))) return record;
-			changed.push(record.id);
-			return {
-				...record,
-				status: "orphaned"
-			};
-		}),
+		records: next,
 		changed
 	};
 }
@@ -659,25 +786,25 @@ function isRecord(value) {
 */
 function createWorktreeRegistry(file) {
 	return {
-		list() {
-			const parsed = readJson(file);
+		async list() {
+			const parsed = await readJson(file);
 			if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) return [];
 			return parsed.entries.filter(isRecord);
 		},
-		replace(entries) {
-			writeJsonAtomic(file, {
+		async replace(entries) {
+			await writeJsonAtomic(file, {
 				version: 1,
 				entries
 			});
 		},
 		async transaction(operation, signal) {
 			const lock = `${file}.lock`;
-			node_fs.default.mkdirSync(node_path.default.dirname(file), { recursive: true });
+			await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
 			const deadline = Date.now() + LOCK_WAIT_MS;
 			for (;;) {
 				signal?.throwIfAborted();
 				try {
-					node_fs.default.mkdirSync(lock, { mode: 448 });
+					await node_fs_promises.default.mkdir(lock, { mode: 448 });
 					break;
 				} catch (error) {
 					if (error.code !== "EEXIST") throw error;
@@ -686,14 +813,14 @@ function createWorktreeRegistry(file) {
 				}
 			}
 			try {
-				node_fs.default.writeFileSync(node_path.default.join(lock, "owner.json"), JSON.stringify({
+				await node_fs_promises.default.writeFile(node_path.default.join(lock, "owner.json"), JSON.stringify({
 					pid: process.pid,
 					createdAt: (/* @__PURE__ */ new Date()).toISOString()
 				}), { mode: 384 });
 				signal?.throwIfAborted();
 				return await operation();
 			} finally {
-				node_fs.default.rmSync(lock, { recursive: true });
+				await node_fs_promises.default.rm(lock, { recursive: true });
 			}
 		}
 	};
@@ -703,8 +830,26 @@ function createWorktreeRegistry(file) {
 const GIT_WORKTREE_DELEGATION_KIND = "git.worktree.delegation";
 const GIT_WORKTREE_MESSAGE_KIND = "git.worktree.message";
 const GIT_WORKTREE_REPORT_KIND = "git.worktree.report";
+/**
+* The repository's worktree setup as one shell command, or undefined when it asks for none.
+* Read from the checkout the spawn starts in, so an uncommitted edit applies at once.
+*/
+async function readWorktreeSetup(root) {
+	const file = node_path.default.join(root, WORKTREE_CONFIG_FILE);
+	let setup;
+	try {
+		setup = (0, js_yaml.load)(await node_fs_promises.default.readFile(file, "utf8"))?.setup;
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw new PoGitExpectedError("invalid_request", `${WORKTREE_CONFIG_FILE} is not valid YAML (${error.message}).`, false, "Fix the file and try again.");
+	}
+	const commands = [setup ?? []].flat();
+	if (!commands.every((command) => typeof command === "string")) throw new PoGitExpectedError("invalid_request", `${WORKTREE_CONFIG_FILE} setup must be a command or a list of commands.`, false, "Fix the file and try again.");
+	return commands.filter((command) => command.trim() !== "").join(" && ") || void 0;
+}
 function createWorktreeOperations(deps) {
 	const { git } = deps;
+	const rift = deps.rift ?? createWorktreeRift();
 	const sessionService = deps.sessionService;
 	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
 	const requireSessionService = () => {
@@ -723,8 +868,19 @@ function createWorktreeOperations(deps) {
 	};
 	const probe = {
 		alive: (record) => requireSessionService().isLive(record.sessionId),
-		exists: (path) => node_fs.default.existsSync(path)
+		exists: (path) => node_fs_promises.default.access(path).then(() => true, () => false)
 	};
+	/** What git lists as worktrees, plus Rift workspaces, which git cannot see. */
+	const listedPaths = async (root, records) => {
+		const rifts = records.filter((record) => record.backend === "rift");
+		const present = await Promise.all(rifts.map((record) => probe.exists(record.path)));
+		return [...await git.listWorktreePaths(root), ...rifts.filter((_, index) => present[index]).map((r) => r.path)];
+	};
+	const removeCheckout = (root, record, force) => record.backend === "rift" ? rift.remove(record.path) : git.removeWorktree({
+		repositoryRoot: root,
+		path: record.path,
+		force
+	});
 	/**
 	* Everything an action needs about the repository it is acting on.
 	*
@@ -735,11 +891,11 @@ function createWorktreeOperations(deps) {
 	const resolve = async (context) => {
 		const root = await git.repositoryRoot(context.cwd);
 		if (root === void 0) throw new PoGitExpectedError("not_a_repository", `${context.cwd} is not inside a git repository.`, false, "Run this from a repository checkout.");
-		const store = createWorktreeRegistry(registryFile(root, deps.homeDir));
+		const store = createWorktreeRegistry(await registryFile(root, deps.homeDir));
 		return {
 			root,
 			store,
-			records: store.list()
+			records: await store.list()
 		};
 	};
 	const require$1 = (records, id) => {
@@ -790,11 +946,11 @@ function createWorktreeOperations(deps) {
 				const expectedPath = worktreeDirectory({
 					worktreesRoot: worktreesRoot(deps.homeDir),
 					repositoryLabel: repositoryLabel(root),
-					repositoryId: repositoryId(root),
+					repositoryId: await repositoryId(root),
 					branch: request.branch,
 					shortId: shortId(reserved.sessionId)
 				});
-				if (existing.parentSessionId !== parentSessionId || existing.repositoryRoot !== root || existing.branch !== request.branch || existing.path !== expectedPath || existing.path !== reserved?.cwd || request.baseRef !== void 0 && existing.baseRef !== request.baseRef || !node_fs.default.existsSync(existing.path) || !(await git.listWorktreePaths(root)).includes(existing.path) || await git.repositoryRoot(existing.path) !== existing.path || await git.currentBranch(existing.path) !== request.branch) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing branch and checkout; they will not be replaced.");
+				if (existing.parentSessionId !== parentSessionId || existing.repositoryRoot !== root || existing.branch !== request.branch || existing.path !== expectedPath || existing.path !== reserved?.cwd || request.baseRef !== void 0 && existing.baseRef !== request.baseRef || !await probe.exists(existing.path) || !(await listedPaths(root, records)).includes(existing.path) || await git.repositoryRoot(existing.path) !== existing.path || await git.currentBranch(existing.path) !== request.branch) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing branch and checkout; they will not be replaced.");
 				if (!requireSessionService().isLive(existing.sessionId)) {
 					if ((await requireSessionService().create({
 						cwd: existing.path,
@@ -814,18 +970,20 @@ function createWorktreeOperations(deps) {
 			});
 			if (refusal !== void 0) throw new PoGitExpectedError("worktree_exists", refusal, false, "Pick another branch name, or close it.");
 			const taskDelivery = request.task === void 0 ? void 0 : requireSessionDelivery();
+			const setup = await readWorktreeSetup(root);
+			const useRift = await rift.enabled(root);
 			const existingBranch = request.checkout === "existing";
 			const id = shortId(reserved?.sessionId ?? (0, node_crypto.randomUUID)());
 			let path = worktreeDirectory({
 				worktreesRoot: worktreesRoot(deps.homeDir),
 				repositoryLabel: repositoryLabel(root),
-				repositoryId: repositoryId(root),
+				repositoryId: await repositoryId(root),
 				branch: request.branch,
 				shortId: id
 			});
 			if (request.reservationId !== void 0) path = (await reservations.prepare(request.reservationId, parentSessionId, path)).cwd;
-			const recovering = reserved?.cwd !== void 0 && node_fs.default.existsSync(path);
-			if (recovering && (!(await git.listWorktreePaths(root)).includes(path) || await git.currentBranch(path) !== request.branch)) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing directory; it will not be replaced.");
+			const recovering = reserved?.cwd !== void 0 && await probe.exists(path);
+			if (recovering && (!(useRift ? await git.repositoryRoot(path) === path : (await git.listWorktreePaths(root)).includes(path)) || await git.currentBranch(path) !== request.branch)) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing directory; it will not be replaced.");
 			if (!recovering) {
 				if (existingBranch) {
 					const branches = await git.listBranches(root);
@@ -838,11 +996,11 @@ function createWorktreeOperations(deps) {
 			const cancelled = () => options?.signal?.aborted === true;
 			const rollback = async () => {
 				if (reserved) return ` The reserved checkout at ${path} was retained for recovery.`;
-				await git.removeWorktree({
-					repositoryRoot: root,
+				await removeCheckout(root, {
 					path,
-					force: true
-				}).catch(() => void 0);
+					...useRift ? { backend: "rift" } : {}
+				}, true).catch(() => void 0);
+				if (useRift) return "";
 				if (existingBranch && request.remote === void 0) return "";
 				return await git.deleteBranch({
 					repositoryRoot: root,
@@ -851,7 +1009,15 @@ function createWorktreeOperations(deps) {
 			};
 			options?.onProgress?.(`creating branch ${request.branch}\u2026`);
 			if (!recovering) {
-				if (existingBranch) await git.addExistingWorktree({
+				if (useRift) await rift.create({
+					repositoryRoot: root,
+					path,
+					branch: request.branch,
+					baseRef,
+					existing: existingBranch,
+					...request.remote === void 0 ? {} : { remote: request.remote }
+				});
+				else if (existingBranch) await git.addExistingWorktree({
 					repositoryRoot: root,
 					path,
 					branch: request.branch,
@@ -893,20 +1059,30 @@ function createWorktreeOperations(deps) {
 				sessionId,
 				...parented,
 				status: "running",
+				...useRift ? { backend: "rift" } : {},
 				createdAt: now().toISOString()
 			};
 			try {
-				store.replace([...records, record]);
+				await store.replace([...records, record]);
 			} catch (error) {
 				await requireSessionService().close(sessionId).catch(() => void 0);
 				const kept = await rollback();
 				throw new PoGitExpectedError("registry_write_failed", `The worktree was created but the registry could not be written (${error.message}).${kept}`, true, "Check the registry file for permissions or free space, then try again.");
 			}
+			let setupStarted = false;
+			if (setup !== void 0) try {
+				const service = requireSessionService();
+				if (service.prompt === void 0) throw new Error("this host cannot run session commands");
+				await service.prompt(sessionId, `${WORKTREE_SETUP_LAUNCH} ${setup}`);
+				setupStarted = true;
+			} catch (error) {
+				options?.onProgress?.(`worktree setup did not start (${String(error)})`);
+			}
 			if (request.task !== void 0 && taskDelivery !== void 0) try {
 				const receipt = await taskDelivery.deliver({
 					recipientKey: sessionId,
 					kind: GIT_WORKTREE_DELEGATION_KIND,
-					prompt: request.task,
+					prompt: setupStarted ? `${request.task}\n\nThe worktree setup (${setup}) is running as the runner "worktree-setup". Check it with po-runner before relying on installed dependencies or builds.` : request.task,
 					metadata: {
 						worktreeId: record.id,
 						fromRole: "parent",
@@ -929,23 +1105,19 @@ function createWorktreeOperations(deps) {
 			requireOwner(context, record, "close");
 			const refusal = refuseClose({
 				record,
-				dirtyFiles: node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : [],
+				dirtyFiles: await probe.exists(record.path) ? await git.dirtyFiles(record.path) : [],
 				force
 			});
 			if (refusal !== void 0) throw new PoGitExpectedError("worktree_dirty", refusal, false, "Commit the work, or pass force: true.");
 			await requireSessionService().close(record.sessionId);
-			await git.removeWorktree({
-				repositoryRoot: root,
-				path: record.path,
-				force
-			});
-			store.replace(records.filter((entry) => entry.id !== id));
+			await removeCheckout(root, record, force);
+			await store.replace(records.filter((entry) => entry.id !== id));
 			return record;
 		},
 		async list(context) {
 			const { store, records } = await resolve(context);
-			const outcome = reconcile(records, probe);
-			if (outcome.changed.length > 0) store.replace(outcome.records);
+			const outcome = await reconcile(records, probe);
+			if (outcome.changed.length > 0) await store.replace(outcome.records);
 			return outcome.records;
 		},
 		async status(context, id) {
@@ -953,7 +1125,7 @@ function createWorktreeOperations(deps) {
 			const record = require$1(records, id);
 			return {
 				record,
-				dirtyFiles: node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : []
+				dirtyFiles: await probe.exists(record.path) ? await git.dirtyFiles(record.path) : []
 			};
 		},
 		async merge(context, id, message) {
@@ -962,6 +1134,11 @@ function createWorktreeOperations(deps) {
 			requireOwner(context, record, "merge");
 			const parentDirty = await git.dirtyFiles(root);
 			if (parentDirty.length > 0) throw new PoGitExpectedError("worktree_dirty", `The parent checkout has ${String(parentDirty.length)} uncommitted file(s): ${parentDirty.slice(0, 10).join(", ")}.`, false, "Commit or stash the parent checkout first.");
+			if (record.backend === "rift") await rift.fetchBranch({
+				repositoryRoot: root,
+				path: record.path,
+				branch: record.branch
+			});
 			await git.mergeBranch({
 				repositoryRoot: root,
 				branch: record.branch,
@@ -1026,10 +1203,10 @@ function createWorktreeOperations(deps) {
 		},
 		async prune(context, dryRun) {
 			const { root, store, records } = await resolve(context);
-			const reconciled = reconcile(records, probe);
-			const gitPaths = await git.listWorktreePaths(root);
+			const reconciled = await reconcile(records, probe);
+			const gitPaths = await listedPaths(root, reconciled.records);
 			const dirtyByPath = /* @__PURE__ */ new Map();
-			for (const record of reconciled.records) if (record.status === "orphaned" && node_fs.default.existsSync(record.path)) dirtyByPath.set(record.path, await git.dirtyFiles(record.path));
+			for (const record of reconciled.records) if (record.status === "orphaned" && await probe.exists(record.path)) dirtyByPath.set(record.path, await git.dirtyFiles(record.path));
 			const plan = planPrune({
 				records: reconciled.records,
 				gitPaths,
@@ -1037,20 +1214,16 @@ function createWorktreeOperations(deps) {
 				dirtyByPath
 			});
 			if (dryRun) {
-				store.replace(reconciled.records);
+				await store.replace(reconciled.records);
 				return plan;
 			}
-			for (const record of plan.remove) await git.removeWorktree({
-				repositoryRoot: root,
-				path: record.path,
-				force: false
-			});
+			for (const record of plan.remove) await removeCheckout(root, record, false);
 			for (const record of [...plan.remove, ...plan.forget]) if (!await git.deleteBranch({
 				repositoryRoot: root,
 				branch: record.branch
-			}).catch(() => false)) plan.keptBranches.push(record.branch);
+			}).catch(() => false) && record.backend !== "rift") plan.keptBranches.push(record.branch);
 			const dropped = new Set([...plan.remove, ...plan.forget].map((record) => record.id));
-			store.replace(reconciled.records.filter((record) => !dropped.has(record.id)));
+			await store.replace(reconciled.records.filter((record) => !dropped.has(record.id)));
 			return plan;
 		}
 	};
@@ -1072,7 +1245,7 @@ function createWorktreeOperations(deps) {
 	return {
 		...operations,
 		spawn: (context, request, options) => {
-			if (sessionService === void 0) return Promise.reject(new PoGitExpectedError("hub_unavailable", "The cockpit session service is unavailable.", true, "Use the cockpit worktree tool after its Git server facet is available."));
+			if (sessionService === void 0) return Promise.reject(new PoGitExpectedError("hub_unavailable", "The cockpit session service is unavailable.", true, "Use the cockpit worktree tool after its Git server plugin is available."));
 			if (!validRefName(request.branch) || request.baseRef !== void 0 && !validRefName(request.baseRef)) return Promise.reject(new PoGitExpectedError("invalid_request", "That is not a valid branch name.", false, "Pick another name."));
 			if (request.reservationId !== void 0 && context.sessionId === void 0) return Promise.reject(new PoGitExpectedError("invalid_request", "A reserved worktree session requires its owning parent.", false, "Create the session from its pending setup card."));
 			return locked(context, () => operations.spawn(context, request, options), options?.signal);
@@ -1084,6 +1257,36 @@ function createWorktreeOperations(deps) {
 	};
 }
 //#endregion
+Object.defineProperty(exports, "GIT_AUTH_PATH", {
+	enumerable: true,
+	get: function() {
+		return GIT_AUTH_PATH;
+	}
+});
+Object.defineProperty(exports, "GIT_BRANCHES_PATH", {
+	enumerable: true,
+	get: function() {
+		return GIT_BRANCHES_PATH;
+	}
+});
+Object.defineProperty(exports, "GIT_REVIEW_FILE_PATH", {
+	enumerable: true,
+	get: function() {
+		return GIT_REVIEW_FILE_PATH;
+	}
+});
+Object.defineProperty(exports, "GIT_REVIEW_PATH", {
+	enumerable: true,
+	get: function() {
+		return GIT_REVIEW_PATH;
+	}
+});
+Object.defineProperty(exports, "GIT_SESSIONS_PATH", {
+	enumerable: true,
+	get: function() {
+		return GIT_SESSIONS_PATH;
+	}
+});
 Object.defineProperty(exports, "GIT_SESSION_CHANGED_EVENT", {
 	enumerable: true,
 	get: function() {
@@ -1217,4 +1420,4 @@ Object.defineProperty(exports, "writeJsonAtomic", {
 	}
 });
 
-//# sourceMappingURL=worktreeOperations-DGUbUnYU.cjs.map
+//# sourceMappingURL=worktreeOperations-CD7s0YnO.cjs.map