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

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_worktreeOperations = require("./worktreeOperations-DGUbUnYU.cjs");
+const require_worktreeOperations = require("./worktreeOperations-CD7s0YnO.cjs");
 //#region src/services/extensionService/index.ts
 var DefaultGitExtensionService = class {
 	async execute() {

package/dist/index.d.mts

@@ -42,6 +42,8 @@ interface WorktreeRecord {
    */
   parentSessionId?: string;
   status: WorktreeStatus;
+  /** `rift`: a Rift copy-on-write workspace with its own `.git`, not a linked git worktree. */
+  backend?: 'rift';
   /** ISO 8601. */
   createdAt: string;
 }

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["_$___worktreeEvents0.WorktreeMessage"],"sources":["../src/services/worktreeEvents/index.ts","../src/types/worktreeRegistry.ts","../src/services/worktreeNaming/index.ts","../src/services/worktreeOperations/index.ts","../src/types/extension.ts","../src/services/extensionService/index.ts","../src/services/gitDependencies/index.ts"],"mappings":";;;cASa;KASD;UAEK;WACN,gBAAgB;WAChB;WACA;WACA,MAAM;WACN;WACA;;;;;;;;;;;KCRC;cAEC;UAEI;EACf,gBAAgB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;EACA,QAAQ;;EAER;;;;UC8De;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;iBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX;;;UCpHa;;EAEf;;;;;EAKA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,SAAS;;EAET,cAAc;;UAGC;EACf,MAAM,SAAS,iBAAiB,SAAS,sBAAsB,UAAU,eAAe,QAAQ;EAChG,MAAM,SAAS,iBAAiB,YAAY,iBAAiB,QAAQ;EACrE,KAAK,SAAS,kBAAkB,QAAQ;EACxC,OAAO,SAAS,iBAAiB,aAAa;IAAU,QAAQ;IAAgB;;EAChF,MAAM,SAAS,iBAAiB,YAAY,mBAAmB,QAAQ;EACvE,MAAM,SAAS,iBAAiB,kBAAkB,QAAQ,kBAAkB;EAC5E,KAAK,SAAS,iBAAiB,YAAY,kBAAkB;EAC7D,SAAS,SAAS,iBAAiB,aAAa,QAA9BA;;;;KCrDR;UAEK;EACf;EACA,OAAO;;UAGQ;EACf,WAAW,QAAQ;;UAGJ;EACf,SAAS;EACT,YAAY;;;;qBCbD,sCAAsC;EAC3C,WAAW,QAAQ;;;;wBCEX,sBAAsB,YAAW,QAAQ,4BAAiC"}
+{"version":3,"file":"index.d.mts","names":["_$___worktreeEvents0.WorktreeMessage"],"sources":["../src/services/worktreeEvents/index.ts","../src/types/worktreeRegistry.ts","../src/services/worktreeNaming/index.ts","../src/services/worktreeOperations/index.ts","../src/types/extension.ts","../src/services/extensionService/index.ts","../src/services/gitDependencies/index.ts"],"mappings":";;;cASa;KASD;UAEK;WACN,gBAAgB;WAChB;WACA;WACA,MAAM;WACN;WACA;;;;;;;;;;;KCRC;cAEC;UAEI;EACf,gBAAgB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;EACA,QAAQ;;EAER;;EAEA;;;;UC8De;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;iBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX;;;UCpFa;;EAEf;;;;;EAKA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,SAAS;;EAET,cAAc;;UAGC;EACf,MAAM,SAAS,iBAAiB,SAAS,sBAAsB,UAAU,eAAe,QAAQ;EAChG,MAAM,SAAS,iBAAiB,YAAY,iBAAiB,QAAQ;EACrE,KAAK,SAAS,kBAAkB,QAAQ;EACxC,OAAO,SAAS,iBAAiB,aAAa;IAAU,QAAQ;IAAgB;;EAChF,MAAM,SAAS,iBAAiB,YAAY,mBAAmB,QAAQ;EACvE,MAAM,SAAS,iBAAiB,kBAAkB,QAAQ,kBAAkB;EAC5E,KAAK,SAAS,iBAAiB,YAAY,kBAAkB;EAC7D,SAAS,SAAS,iBAAiB,aAAa,QAA9BA;;;;KCvFR;UAEK;EACf;EACA,OAAO;;UAGQ;EACf,WAAW,QAAQ;;UAGJ;EACf,SAAS;EACT,YAAY;;;;qBCbD,sCAAsC;EAC3C,WAAW,QAAQ;;;;wBCEX,sBAAsB,YAAW,QAAQ,4BAAiC"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { b as createWorktreeGit, t as createWorktreeOperations } from "./worktreeOperations-BSeyxUai.mjs";
+import { T as createWorktreeGit, t as createWorktreeOperations } from "./worktreeOperations-B3E4JY4H.mjs";
 //#region src/services/extensionService/index.ts
 var DefaultGitExtensionService = class {
 	async execute() {

package/dist/{worktreeOperations-BSeyxUai.mjs → worktreeOperations-B3E4JY4H.mjs}

@@ -1,8 +1,9 @@
-import { execFile } from "node:child_process";
-import fs from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import fs from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
-import os from "node:os";
 import path from "node:path";
+import { load } from "js-yaml";
+import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
 import { poHomeDirectory } from "@agimon-ai/po-core/piSettings";
 import { setTimeout } from "node:timers/promises";
@@ -19,7 +20,7 @@ import { setTimeout } from "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;
@@ -172,9 +173,9 @@ function createWorktreeGit() {
 				"remove",
 				...force ? ["--force"] : [],
 				path
-			], REMOVE_TIMEOUT_MS);
+			], REMOVE_TIMEOUT_MS$1);
 			if (result.code === 0) return;
-			if (missingWorktree(result.stderr) && !fs.existsSync(path)) {
+			if (missingWorktree(result.stderr) && !await fs.access(path).then(() => true, () => false)) {
 				await prune(repositoryRoot);
 				return;
 			}
@@ -260,6 +261,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;
@@ -295,12 +315,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 = path.dirname(file);
-	fs.mkdirSync(directory, { recursive: true });
-	const temporary = path.join(directory, `.${path.basename(file)}.${String(process.pid)}.tmp`);
-	fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
-	fs.renameSync(temporary, file);
+	await fs.mkdir(directory, { recursive: true });
+	const temporary = path.join(directory, `.${path.basename(file)}.${randomUUID()}.tmp`);
+	await fs.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
+	await fs.rename(temporary, file);
 }
 /**
 * Reads JSON, treating every failure as absent.
@@ -309,9 +329,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(fs.readFileSync(file, "utf8"));
+		return JSON.parse(await fs.readFile(file, "utf8"));
 	} catch {
 		return;
 	}
@@ -330,12 +350,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 = path.resolve(directory);
 	let marker = path.join(root, ".git");
 	let stat;
 	for (;;) try {
-		stat = fs.statSync(marker);
+		stat = await fs.stat(marker);
 		break;
 	} catch {
 		const parent = path.dirname(root);
@@ -346,14 +366,14 @@ function gitCommonDirectory(directory) {
 	if (stat.isDirectory()) return marker;
 	let pointer;
 	try {
-		pointer = fs.readFileSync(marker, "utf8").trim();
+		pointer = (await fs.readFile(marker, "utf8")).trim();
 	} catch {
 		return;
 	}
 	if (!pointer.startsWith("gitdir:")) return void 0;
 	const gitDir = path.resolve(root, pointer.slice(7).trim());
 	try {
-		const common = fs.readFileSync(path.join(gitDir, "commondir"), "utf8").trim();
+		const common = (await fs.readFile(path.join(gitDir, "commondir"), "utf8")).trim();
 		return path.resolve(gitDir, common);
 	} catch {
 		return gitDir;
@@ -372,8 +392,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:${path.resolve(root)}` : `git:${common}`;
 	return createHash("sha256").update(token).digest("hex").slice(0, ID_LENGTH);
 }
@@ -409,22 +429,26 @@ function credentialsFile(homeDir = os.homedir()) {
 	return path.join(poGitRoot(homeDir), "credentials.json");
 }
 /** One registry file per repository, keyed by the shared git directory. */
-function registryFile(repositoryRoot, homeDir = os.homedir()) {
-	const id = repositoryId(repositoryRoot);
+async function registryFile(repositoryRoot, homeDir = os.homedir()) {
+	const id = await repositoryId(repositoryRoot);
 	const root = path.join(poGitRoot(homeDir), "registry");
 	const canonical = path.join(root, id, "worktrees.json");
-	if (fs.existsSync(canonical)) return canonical;
+	if (await fs.access(canonical).then(() => true, () => false)) return canonical;
 	let names;
 	try {
-		names = fs.readdirSync(root);
+		names = await fs.readdir(root);
 	} catch {
 		return canonical;
 	}
-	const legacyFiles = names.filter((entry) => entry.endsWith(`--${id}`)).sort().map((entry) => path.join(root, entry, "worktrees.json")).filter((file) => fs.existsSync(file));
+	const legacyFiles = [];
+	for (const entry of names.filter((name) => name.endsWith(`--${id}`)).sort()) {
+		const file = path.join(root, entry, "worktrees.json");
+		if (await fs.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;
@@ -435,20 +459,119 @@ function registryFile(repositoryRoot, homeDir = os.homedir()) {
 		}
 	}
 	const temporary = `${canonical}.${randomUUID()}.migration`;
-	writeJsonAtomic(temporary, {
+	await writeJsonAtomic(temporary, {
 		version: 1,
 		entries: [...entries.values()]
 	});
 	try {
-		fs.linkSync(temporary, canonical);
+		await fs.link(temporary, canonical);
 	} catch (error) {
 		if (error.code !== "EEXIST") throw error;
 	} finally {
-		fs.rmSync(temporary);
+		await fs.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 = 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) => fs.access(file).then(() => true, () => false);
+function createWorktreeRift() {
+	const remove = async (target) => {
+		if (!await exists(target)) return;
+		const result = await rift(path.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(path.join(repositoryRoot, RIFT_CONFIG_FILE)),
+		async create({ repositoryRoot, path: target, branch, baseRef, existing, remote }) {
+			if (!await exists(path.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 fs.mkdir(path.dirname(target), { recursive: true });
+			const created = await rift(repositoryRoot, [
+				"create",
+				repositoryRoot,
+				"--into",
+				path.dirname(target),
+				"--name",
+				path.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";
@@ -563,18 +686,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
 	};
 }
@@ -634,25 +761,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`;
-			fs.mkdirSync(path.dirname(file), { recursive: true });
+			await fs.mkdir(path.dirname(file), { recursive: true });
 			const deadline = Date.now() + LOCK_WAIT_MS;
 			for (;;) {
 				signal?.throwIfAborted();
 				try {
-					fs.mkdirSync(lock, { mode: 448 });
+					await fs.mkdir(lock, { mode: 448 });
 					break;
 				} catch (error) {
 					if (error.code !== "EEXIST") throw error;
@@ -661,14 +788,14 @@ function createWorktreeRegistry(file) {
 				}
 			}
 			try {
-				fs.writeFileSync(path.join(lock, "owner.json"), JSON.stringify({
+				await fs.writeFile(path.join(lock, "owner.json"), JSON.stringify({
 					pid: process.pid,
 					createdAt: (/* @__PURE__ */ new Date()).toISOString()
 				}), { mode: 384 });
 				signal?.throwIfAborted();
 				return await operation();
 			} finally {
-				fs.rmSync(lock, { recursive: true });
+				await fs.rm(lock, { recursive: true });
 			}
 		}
 	};
@@ -678,8 +805,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 = path.join(root, WORKTREE_CONFIG_FILE);
+	let setup;
+	try {
+		setup = load(await fs.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 = () => {
@@ -698,8 +843,19 @@ function createWorktreeOperations(deps) {
 	};
 	const probe = {
 		alive: (record) => requireSessionService().isLive(record.sessionId),
-		exists: (path) => fs.existsSync(path)
+		exists: (path) => fs.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.
 	*
@@ -710,11 +866,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 = (records, id) => {
@@ -765,11 +921,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 || !fs.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,
@@ -789,18 +945,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 ?? 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 && fs.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);
@@ -813,11 +971,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,
@@ -826,7 +984,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,
@@ -868,20 +1034,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",
@@ -904,23 +1080,19 @@ function createWorktreeOperations(deps) {
 			requireOwner(context, record, "close");
 			const refusal = refuseClose({
 				record,
-				dirtyFiles: fs.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) {
@@ -928,7 +1100,7 @@ function createWorktreeOperations(deps) {
 			const record = require(records, id);
 			return {
 				record,
-				dirtyFiles: fs.existsSync(record.path) ? await git.dirtyFiles(record.path) : []
+				dirtyFiles: await probe.exists(record.path) ? await git.dirtyFiles(record.path) : []
 			};
 		},
 		async merge(context, id, message) {
@@ -937,6 +1109,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,
@@ -1001,10 +1178,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" && fs.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,
@@ -1012,20 +1189,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;
 		}
 	};
@@ -1047,7 +1220,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);
@@ -1059,6 +1232,6 @@ function createWorktreeOperations(deps) {
 	};
 }
 //#endregion
-export { NETWORK_TIMEOUT_MS as _, GIT_WORKTREE_LIFECYCLE_EVENT as a, createWorktreeGit as b, isWorktreeLifecycleEvent as c, registryFile as d, readJson as f, invalidRequest as g, PoGitExpectedError as h, GIT_SESSION_CHANGED_EVENT as i, credentialsFile as l, HubUnavailableError as m, createWorktreeRegistry as n, createWorktreeMessageInbox as o, writeJsonAtomic as p, validRefName as r, isSessionChangedEvent as s, createWorktreeOperations as t, poGitRoot as u, READ_TIMEOUT_MS as v, runGit as x, REBASE_TIMEOUT_MS as y };
+export { READ_TIMEOUT_MS as C, runGit as E, NETWORK_TIMEOUT_MS as S, createWorktreeGit as T, GIT_AUTH_PATH as _, GIT_WORKTREE_LIFECYCLE_EVENT as a, GIT_REVIEW_PATH as b, isWorktreeLifecycleEvent as c, registryFile as d, readJson as f, invalidRequest as g, PoGitExpectedError as h, GIT_SESSION_CHANGED_EVENT as i, credentialsFile as l, HubUnavailableError as m, createWorktreeRegistry as n, createWorktreeMessageInbox as o, writeJsonAtomic as p, validRefName as r, isSessionChangedEvent as s, createWorktreeOperations as t, poGitRoot as u, GIT_BRANCHES_PATH as v, REBASE_TIMEOUT_MS as w, GIT_SESSIONS_PATH as x, GIT_REVIEW_FILE_PATH as y };
 
-//# sourceMappingURL=worktreeOperations-BSeyxUai.mjs.map
+//# sourceMappingURL=worktreeOperations-B3E4JY4H.mjs.map