@agimon-ai/po-git 0.0.0-alpha.12 → 0.0.0-alpha.121

package/dist/extensions/server.cjs

@@ -2,17 +2,21 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_worktreeOperations = require("../worktreeOperations-DGUbUnYU.cjs");
-let node_fs = require("node:fs");
-node_fs = require_worktreeOperations.__toESM(node_fs, 1);
-let node_os = require("node:os");
-node_os = require_worktreeOperations.__toESM(node_os, 1);
+const require_worktreeOperations = require("../worktreeOperations-0Jrjcbg7.cjs");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_worktreeOperations.__toESM(node_fs_promises, 1);
 let node_path = require("node:path");
 node_path = require_worktreeOperations.__toESM(node_path, 1);
-let _agimon_ai_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let node_os = require("node:os");
+node_os = require_worktreeOperations.__toESM(node_os, 1);
+let _agimon_ai_po_core_serverPlugin = require("@agimon-ai/po-core/serverPlugin");
 let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
+let _agimon_ai_po_core_codemode = require("@agimon-ai/po-core/codemode");
 let _agimon_ai_po_session = require("@agimon-ai/po-session");
 let typebox = require("typebox");
+let _agimon_ai_po_core_platform = require("@agimon-ai/po-core/platform");
+let _agimon_ai_po_core_packageApi = require("@agimon-ai/po-core/packageApi");
+let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
 //#region src/schemas/runWorktreeTool.ts
 /**
 * The tool's action vocabulary.
@@ -254,7 +258,8 @@ async function executeRunWorktreeTool(params, operations, context, options = {})
 				content: text(describe(record, context.sessionId), `Session: ${record.sessionId}`, dirtyFiles.length === 0 ? "Clean." : `${String(dirtyFiles.length)} uncommitted file(s): ${dirtyFiles.slice(0, 20).join(", ")}`),
 				details: {
 					action: params.action,
-					records: [record]
+					records: [record],
+					dirtyFiles
 				}
 			};
 		}
@@ -278,7 +283,10 @@ async function executeRunWorktreeTool(params, operations, context, options = {})
 			const waiting = await operations.messages(context, params.id);
 			return {
 				content: waiting.length === 0 ? text("No messages.") : text(`${String(waiting.length)} message(s):`, ...waiting.map((entry) => `[${entry.sentAt}] ${entry.from}: ${entry.text}`)),
-				details: { action: params.action }
+				details: {
+					action: params.action,
+					messages: waiting
+				}
 			};
 		}
 		case WORKTREE_ACTIONS.prune: {
@@ -293,12 +301,172 @@ async function executeRunWorktreeTool(params, operations, context, options = {})
 					`Untracked directories, left alone: ${plan.untracked.length === 0 ? "none" : plan.untracked.join(", ")}`,
 					...plan.keptBranches.length === 0 ? [] : [`Branches kept, they hold commits: ${plan.keptBranches.join(", ")}`]
 				]),
-				details: { action: params.action }
+				details: {
+					action: params.action,
+					plan
+				}
 			};
 		}
 	}
 }
 //#endregion
+//#region src/services/worktreeNamespace/index.ts
+const DECLARATIONS = `type WorktreeStatus = 'spawning' | 'running' | 'closing' | 'orphaned';
+
+interface Worktree {
+  id: string;
+  branch: string;
+  baseRef: string;
+  /** Absolute path of the checkout, under ~/.po/git/worktrees. */
+  path: string;
+  repositoryRoot: string;
+  /** The session running inside the worktree. */
+  sessionId: string;
+  parentSessionId?: string;
+  status: WorktreeStatus;
+  createdAt: string;
+  /** How your session relates to it: 'parent' spawned it, 'child' runs inside it, 'other' is neither. */
+  relationship: 'parent' | 'child' | 'other';
+}
+
+interface WorktreeMessage {
+  worktreeId: string;
+  fromSessionId: string;
+  from: 'parent' | 'child';
+  text: string;
+  sentAt: string;
+}
+
+interface PrunePlan {
+  remove: Worktree[];
+  forget: Worktree[];
+  /** Kept because they hold uncommitted work. */
+  keptDirty: Worktree[];
+  untracked: string[];
+  /** Branches kept because they hold commits. */
+  keptBranches: string[];
+}
+
+declare const worktrees: {
+  /** Every worktree for this repository. */
+  list(): Promise<Worktree[]>;
+  /** One worktree and its uncommitted files. */
+  status(id: string): Promise<{ worktree: Worktree; dirtyFiles: string[] }>;
+  /**
+   * Create a worktree on a new branch and start a Po session in it, nested under this one. baseRef defaults to
+   * the current branch's remote-tracking ref, then the remote default branch; name labels it in the rail; task is
+   * the new session's first message. Setup can be slow, so give exec a larger timeoutMs.
+   */
+  spawn(request: { branch: string; baseRef?: string; name?: string; task?: string }): Promise<Worktree>;
+  /** Stop the worktree's session and delete its checkout. Refused on a dirty tree unless force is true. */
+  close(id: string, options?: { force?: boolean }): Promise<Worktree>;
+  /** Merge the worktree's branch into this checkout. Refused when this checkout is dirty. */
+  merge(id: string, options?: { message?: string }): Promise<Worktree>;
+  /** Remove orphaned worktrees. With dryRun, only return the plan. */
+  prune(options?: { dryRun?: boolean }): Promise<PrunePlan>;
+  /**
+   * Message the other side of a worktree. Use the record with relationship 'child' to report to your parent,
+   * and 'parent' to reach your own children. 'other' records are not communication edges.
+   */
+  send(id: string, message: string): Promise<void>;
+  /** Messages waiting for you from a worktree. */
+  messages(id: string): Promise<WorktreeMessage[]>;
+};`;
+const json = (value) => JSON.parse(JSON.stringify(value));
+/** Git worktrees for code mode: the actions of `run_worktree` as methods, returning records instead of text. */
+function createWorktreeNamespace(options) {
+	return {
+		name: "worktrees",
+		summary: "Git worktrees, each with its own Po session nested under this one: worktrees.list, status, spawn, close, merge, prune, send and messages.",
+		declarations: DECLARATIONS,
+		bind(run) {
+			if (run.sessionId !== options.execution.sessionId) throw new Error("Worktrees namespace belongs to another session.");
+			let disposed = false;
+			run.onDispose(() => {
+				disposed = true;
+			});
+			const view = (record) => ({
+				...record,
+				relationship: record.parentSessionId === options.execution.sessionId ? "parent" : record.sessionId === options.execution.sessionId ? "child" : "other"
+			});
+			/** One `run_worktree` action through the tool's own code, so the tool and the namespace cannot drift. */
+			const act = async (name, action, input) => {
+				run.signal.throwIfAborted();
+				if (disposed) throw new Error("Worktrees namespace run is disposed.");
+				options.assertAvailable();
+				const params = validateParams({
+					action,
+					...typeof input === "object" && input !== null ? input : {}
+				});
+				const context = {
+					cwd: options.execution.cwd,
+					sessionId: options.execution.sessionId
+				};
+				const started = Date.now();
+				try {
+					const result = await executeRunWorktreeTool(params, options.operations, context, { signal: run.signal });
+					options.assertAvailable();
+					run.record?.({
+						name: `worktrees.${name}`,
+						tool: RUN_WORKTREE_TOOL_NAME,
+						args: params,
+						ok: true,
+						ms: Date.now() - started,
+						result
+					});
+					return result;
+				} catch (error) {
+					run.record?.({
+						name: `worktrees.${name}`,
+						tool: RUN_WORKTREE_TOOL_NAME,
+						args: params,
+						ok: false,
+						ms: Date.now() - started,
+						error: error instanceof Error ? error.message : String(error)
+					});
+					throw error;
+				}
+			};
+			const record = (result) => view(result.details.records[0]);
+			const members = Object.create(null);
+			members.list = async () => json((await act("list", "list", {})).details.records.map(view));
+			members.status = async (id) => {
+				const { details } = await act("status", "status", { id });
+				return json({
+					worktree: view(details.records[0]),
+					dirtyFiles: details.dirtyFiles ?? []
+				});
+			};
+			members.spawn = async (request) => json(record(await act("spawn", "spawn_worktree", request)));
+			members.close = async (id, settings) => json(record(await act("close", "close_worktree", {
+				...settings,
+				id
+			})));
+			members.merge = async (id, settings) => json(record(await act("merge", "merge", {
+				...settings,
+				id
+			})));
+			members.prune = async (settings) => {
+				const { plan } = (await act("prune", "prune", settings)).details;
+				return json({
+					...plan,
+					remove: plan.remove.map(view),
+					forget: plan.forget.map(view),
+					keptDirty: plan.keptDirty.map(view)
+				});
+			};
+			members.send = async (id, message) => {
+				await act("send", "send", {
+					id,
+					message
+				});
+			};
+			members.messages = async (id) => json((await act("messages", "messages", { id })).details.messages);
+			return members;
+		}
+	};
+}
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/root.server.ts
 function progressResult(action, label) {
 	return {
@@ -309,9 +477,9 @@ function progressResult(action, label) {
 		details: { action }
 	};
 }
-function createGitSession({ context, host: serverHost }) {
-	if (serverHost.context.directEvents === void 0) throw new Error("Git headless facet requires the session direct event bus.");
-	if (serverHost.context.sessionId === void 0) throw new Error("Git headless facet requires a session identity.");
+function createGitSession({ context, host: serverHost, agent, signal }) {
+	if (serverHost.context.directEvents === void 0) throw new Error("Git server plugin requires the session direct event bus.");
+	if (serverHost.context.sessionId === void 0) throw new Error("Git server plugin requires a session identity.");
 	const sessionId = serverHost.context.sessionId;
 	const directEvents = serverHost.context.directEvents;
 	const messageInbox = require_worktreeOperations.createWorktreeMessageInbox(directEvents, sessionId);
@@ -322,20 +490,12 @@ function createGitSession({ context, host: serverHost }) {
 		sessionDelivery: () => (0, _agimon_ai_po_session.readPoSessionDelivery)(context)
 	});
 	const resources = [{
-		when: {
-			state: { "minor-mode": "help" },
-			attribution: {
-				kind: "minor",
-				mode: "help"
-			}
-		},
-		name: "po-git",
-		kind: "context",
-		read: () => (0, _agimon_ai_po_core_serverFacet.readPackageResource)(require("url").pathToFileURL(__filename).href, "llms.txt")
-	}, {
-		name: "po-use-git",
+		name: "codemode-how-to-git",
+		description: "Hand a branch of work to a separate session in its own checkout, keeping the current checkout untouched. Use for a long refactor, a risky migration, or parallel features that touch the same files; not for parallel work on one branch.",
 		kind: "skill",
-		read: () => (0, _agimon_ai_po_core_serverFacet.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/po-use-git/SKILL.md")
+		pinned: true,
+		path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-git/SKILL.md"),
+		read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-git/SKILL.md")
 	}];
 	const tool = {
 		name: RUN_WORKTREE_TOOL_NAME,
@@ -355,17 +515,37 @@ function createGitSession({ context, host: serverHost }) {
 	const changed = (_event, execution) => {
 		directEvents.publish(require_worktreeOperations.GIT_SESSION_CHANGED_EVENT, execution.sessionId, { version: 1 });
 	};
+	const hooks = [{
+		event: "tool_execution_end",
+		handle: changed
+	}, {
+		event: "agent_settled",
+		handle: changed
+	}];
+	if (agent) {
+		const namespace = createWorktreeNamespace({
+			operations,
+			execution: agent.context,
+			assertAvailable: () => {
+				if (signal?.aborted) throw new Error("Git session is unavailable.");
+			}
+		});
+		context.inject([_agimon_ai_po_core_codemode.PO_CODEMODE_SERVICE], (scoped) => {
+			const codemode = (0, _agimon_ai_po_core_codemode.readPoCodemode)(scoped);
+			if (!codemode) return void 0;
+			const registration = codemode.register("@agimon-ai/po-git", namespace);
+			const restriction = agent.registerToolRestriction({ excludedTools: [RUN_WORKTREE_TOOL_NAME] });
+			return () => {
+				restriction.dispose();
+				registration.dispose();
+			};
+		});
+	}
 	return {
 		value: {
 			resources,
 			tool,
-			hooks: [{
-				event: "tool_execution_end",
-				handle: changed
-			}, {
-				event: "agent_settled",
-				handle: changed
-			}]
+			hooks
 		},
 		onDispose: () => messageInbox.close()
 	};
@@ -476,11 +656,11 @@ const NAME_STATUS = {
 	T: "modified"
 };
 /** Line count of a small regular file, or undefined when it is binary, large, or not a regular file. */
-function untrackedLines(root, relPath) {
+async function untrackedLines(root, relPath) {
 	const absolute = node_path.default.join(root, relPath);
 	let stat;
 	try {
-		stat = node_fs.default.lstatSync(absolute);
+		stat = await node_fs_promises.default.lstat(absolute);
 	} catch {
 		return;
 	}
@@ -489,7 +669,7 @@ function untrackedLines(root, relPath) {
 		binary: false
 	};
 	if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return void 0;
-	const content = node_fs.default.readFileSync(absolute);
+	const content = await node_fs_promises.default.readFile(absolute);
 	if (content.subarray(0, BINARY_PROBE_BYTES).includes(0)) return {
 		lines: 0,
 		binary: true
@@ -612,8 +792,8 @@ function createBranchDiff() {
 				"--exclude-standard",
 				"-z"
 			]));
-			untracked.forEach((relPath, index) => {
-				const counted = index < MAX_UNTRACKED_COUNTED ? untrackedLines(root, relPath) : void 0;
+			for (const [index, relPath] of untracked.entries()) {
+				const counted = index < MAX_UNTRACKED_COUNTED ? await untrackedLines(root, relPath) : void 0;
 				entries.push({
 					path: relPath,
 					status: "untracked",
@@ -621,18 +801,20 @@ function createBranchDiff() {
 					removed: 0,
 					...counted?.binary ? { binary: true } : {}
 				});
-			});
+			}
 			entries.sort((left, right) => left.path.localeCompare(right.path));
 			const conflicts = [...unmerged];
-			const rebasing = [await readLine$1(root, [
+			const rebaseMerge = await readLine$1(root, [
 				"rev-parse",
 				"--git-path",
 				"rebase-merge"
-			]), await readLine$1(root, [
+			]);
+			const rebaseApply = await readLine$1(root, [
 				"rev-parse",
 				"--git-path",
 				"rebase-apply"
-			])].some((gitPath) => gitPath !== void 0 && node_fs.default.existsSync(node_path.default.resolve(root, gitPath)));
+			]);
+			const rebasing = (await Promise.all([rebaseMerge, rebaseApply].map(async (gitPath) => gitPath === void 0 ? false : node_fs_promises.default.access(node_path.default.resolve(root, gitPath)).then(() => true, () => false)))).some(Boolean);
 			const upstreamRef = branch === void 0 ? void 0 : await upstreamOf(root, branch);
 			let upstream;
 			if (upstreamRef !== void 0) {
@@ -677,7 +859,7 @@ function createBranchDiff() {
 			if (entry === void 0) throw new Error("That path is not in this review.");
 			if (entry.status === "untracked") {
 				const absolute = node_path.default.join(review.root, entry.path);
-				const stat = node_fs.default.lstatSync(absolute);
+				const stat = await node_fs_promises.default.lstat(absolute);
 				if (stat.isSymbolicLink()) return {
 					path: entry.path,
 					hunks: [{
@@ -685,7 +867,7 @@ function createBranchDiff() {
 						rows: [{
 							marker: "+",
 							line: 1,
-							content: node_fs.default.readlinkSync(absolute)
+							content: await node_fs_promises.default.readlink(absolute)
 						}]
 					}]
 				};
@@ -694,7 +876,7 @@ function createBranchDiff() {
 					hunks: [],
 					tooLarge: true
 				};
-				const content = node_fs.default.readFileSync(absolute);
+				const content = await node_fs_promises.default.readFile(absolute);
 				if (content.subarray(0, BINARY_PROBE_BYTES).includes(0)) return {
 					path: entry.path,
 					hunks: [],
@@ -811,9 +993,9 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** The workspace key: the canonical root, so a symlinked path and its target share one entry. */
-function workspaceKey(workspaceRoot) {
+async function workspaceKey(workspaceRoot) {
 	try {
-		return node_fs.default.realpathSync(workspaceRoot);
+		return await node_fs_promises.default.realpath(workspaceRoot);
 	} catch {
 		return node_path.default.resolve(workspaceRoot);
 	}
@@ -862,7 +1044,7 @@ function publicView(config) {
 * the saved one, and only for the same host: a token never follows a host it
 * was not entered for.
 */
-function parseGitAuthSave(request, current, homeDir) {
+async function parseGitAuthSave(request, current, homeDir) {
 	if (!isRecord(request)) throw require_worktreeOperations.invalidRequest("The git auth request is not an object.", "Send method none, ssh or https.");
 	if (request.method === "none") return { method: "none" };
 	if (request.method === "ssh") {
@@ -872,7 +1054,7 @@ function parseGitAuthSave(request, current, homeDir) {
 		if (!keyPath.startsWith("/") && !keyPath.startsWith("~/")) throw require_worktreeOperations.invalidRequest("The key path is not absolute.", "Give the key as an absolute path or one under ~/.");
 		let isFile = false;
 		try {
-			isFile = node_fs.default.statSync(expandHome(keyPath, homeDir)).isFile();
+			isFile = (await node_fs_promises.default.stat(expandHome(keyPath, homeDir))).isFile();
 		} catch {
 			isFile = false;
 		}
@@ -907,16 +1089,16 @@ function parseGitAuthSave(request, current, homeDir) {
 	throw require_worktreeOperations.invalidRequest("The git auth method is unknown.", "Send method none, ssh or https.");
 }
 /** Tightens a file or folder something left readable by group or others. */
-function tighten(target, mode) {
+async function tighten(target, mode) {
 	try {
-		if ((node_fs.default.statSync(target).mode & LOOSE_BITS) !== 0) node_fs.default.chmodSync(target, mode);
+		if (((await node_fs_promises.default.stat(target)).mode & LOOSE_BITS) !== 0) await node_fs_promises.default.chmod(target, mode);
 	} catch {}
 }
 function createGitAuthStore(homeDir = node_os.default.homedir()) {
 	const file = require_worktreeOperations.credentialsFile(homeDir);
-	const readFile = () => {
-		tighten(file, OWNER_ONLY_FILE);
-		const raw = require_worktreeOperations.readJson(file);
+	const readFile = async () => {
+		await tighten(file, OWNER_ONLY_FILE);
+		const raw = await require_worktreeOperations.readJson(file);
 		const workspaces = {};
 		if (isRecord(raw) && raw.version === 1 && isRecord(raw.workspaces)) for (const [key, value] of Object.entries(raw.workspaces)) {
 			const config = parseConfig(value);
@@ -927,28 +1109,28 @@ function createGitAuthStore(homeDir = node_os.default.homedir()) {
 			workspaces
 		};
 	};
-	const read = (workspaceRoot) => readFile().workspaces[workspaceKey(workspaceRoot)] ?? { method: "none" };
+	const read = async (workspaceRoot) => (await readFile()).workspaces[await workspaceKey(workspaceRoot)] ?? { method: "none" };
 	return {
 		read,
-		view: (workspaceRoot) => publicView(read(workspaceRoot)),
-		save(workspaceRoot, request) {
-			const key = workspaceKey(workspaceRoot);
-			const current = readFile();
-			const next = parseGitAuthSave(request, current.workspaces[key] ?? { method: "none" }, homeDir);
+		view: async (workspaceRoot) => publicView(await read(workspaceRoot)),
+		async save(workspaceRoot, request) {
+			const key = await workspaceKey(workspaceRoot);
+			const current = await readFile();
+			const next = await parseGitAuthSave(request, current.workspaces[key] ?? { method: "none" }, homeDir);
 			const root = require_worktreeOperations.poGitRoot(homeDir);
-			node_fs.default.mkdirSync(root, {
+			await node_fs_promises.default.mkdir(root, {
 				recursive: true,
 				mode: OWNER_ONLY_DIRECTORY
 			});
-			node_fs.default.chmodSync(root, OWNER_ONLY_DIRECTORY);
+			await node_fs_promises.default.chmod(root, OWNER_ONLY_DIRECTORY);
 			const workspaces = { ...current.workspaces };
 			if (next.method === "none") delete workspaces[key];
 			else workspaces[key] = next;
-			require_worktreeOperations.writeJsonAtomic(file, {
+			await require_worktreeOperations.writeJsonAtomic(file, {
 				version: 1,
 				workspaces
 			});
-			node_fs.default.chmodSync(file, OWNER_ONLY_FILE);
+			await node_fs_promises.default.chmod(file, OWNER_ONLY_FILE);
 			return publicView(next);
 		}
 	};
@@ -1067,7 +1249,13 @@ function newSessionRequest(body) {
 	if (branch === void 0 || branch === false || !require_worktreeOperations.validRefName(branch)) return { error: "A valid branch name is required." };
 	const name = optionalText(record.name);
 	if (name === false || name !== void 0 && name.length > MAX_NAME_LENGTH) return { error: `The session name must be text of up to ${String(MAX_NAME_LENGTH)} characters.` };
-	const named = name === void 0 ? {} : { name };
+	const chosen = record.selection === void 0 ? {} : (0, _agimon_ai_po_core_hubChannel.parseLaunchSelection)(record.selection);
+	if ("error" in chosen) return chosen;
+	const profile = chosen.selection?.profile;
+	const named = {
+		...name === void 0 ? {} : { name },
+		...profile === void 0 ? {} : { selection: { profile } }
+	};
 	if (record.mode === "existing-branch") {
 		const remote = optionalText(record.remote);
 		if (remote === false || remote !== void 0 && !require_worktreeOperations.validRefName(remote)) return { error: "That remote name is not valid." };
@@ -1113,177 +1301,237 @@ function failed(error) {
 	}, { status: error.retryable ? 503 : 409 });
 	return Response.json({ error: "The worktree operation failed." }, { status: 500 });
 }
-//#endregion
-//#region src/extensions/(backend)/api/git/route.server.ts
-var route_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoute)({
-	basePath: "git",
-	start(context) {
-		if (context.directEvents === void 0) throw new Error("Git hub API requires the direct event bus.");
-		const directEvents = context.directEvents;
-		const publishLifecycle = (sessionId, repositoryRoot) => {
-			directEvents.publish(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, sessionId, {
-				version: 1,
-				repositoryRoot
+function createGitApi(openDirectory) {
+	return {
+		basePath: "git",
+		start(context) {
+			if (context.directEvents === void 0) throw new Error("Git hub API requires the direct event bus.");
+			const directEvents = context.directEvents;
+			const publishLifecycle = (sessionId, repositoryRoot) => {
+				directEvents.publish(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, sessionId, {
+					version: 1,
+					repositoryRoot
+				});
+			};
+			const git = require_worktreeOperations.createWorktreeGit();
+			const operations = require_worktreeOperations.createWorktreeOperations({
+				git,
+				sessionService: context.sessionService,
+				...context.homeDirectory === void 0 ? {} : { homeDir: context.homeDirectory }
 			});
-		};
-		const git = require_worktreeOperations.createWorktreeGit();
-		const operations = require_worktreeOperations.createWorktreeOperations({
-			git,
-			sessionService: context.sessionService,
-			...context.homeDirectory === void 0 ? {} : { homeDir: context.homeDirectory }
-		});
-		/**
-		* The new-session dialog's routes: the workspace's branches, and a top-level
-		* worktree session on one. Workspace-mounted only, and always rooted at the
-		* mount's own workspace, so a request can never name another directory.
-		*/
-		const newSession = async (request, url) => {
-			const isBranches = request.method === "GET" && url.pathname === "/branches";
-			const isCreate = request.method === "POST" && url.pathname === "/sessions";
-			if (!isBranches && !isCreate) return void 0;
-			const workspaceRoot = context.scope === "workspace" ? context.workspaceRoot : void 0;
-			if (workspaceRoot === void 0) return Response.json({ error: "This route belongs to a workspace." }, { status: 404 });
-			if (isBranches) {
-				const repositoryRoot = await git.repositoryRoot(workspaceRoot);
-				const branches = repositoryRoot === void 0 ? {
-					repository: false,
-					local: [],
-					remote: []
-				} : {
-					repository: true,
-					...await git.listBranches(repositoryRoot)
+			/**
+			* The new-session dialog's routes: the workspace's branches, and a top-level
+			* worktree session on one. Workspace-mounted only, and always rooted at the
+			* mount's own workspace, so a request can never name another directory.
+			*/
+			const newSession = async (request, url) => {
+				const isBranches = request.method === "GET" && url.pathname === "/branches";
+				const isCreate = request.method === "POST" && url.pathname === "/sessions";
+				const isDelete = request.method === "DELETE" && url.pathname === "/branches";
+				const isOpen = request.method === "POST" && url.pathname === `/branches/open`;
+				if (!isBranches && !isCreate && !isDelete && !isOpen) return void 0;
+				const workspaceRoot = context.scope === "workspace" ? context.workspaceRoot : void 0;
+				if (workspaceRoot === void 0) return Response.json({ error: "This route belongs to a workspace." }, { status: 404 });
+				if (isBranches) {
+					const repositoryRoot = await git.repositoryRoot(workspaceRoot);
+					const branches = repositoryRoot === void 0 ? {
+						repository: false,
+						local: [],
+						remote: []
+					} : {
+						repository: true,
+						...await git.listBranches(repositoryRoot)
+					};
+					return Response.json(branches);
+				}
+				if (isDelete || isOpen) {
+					if (isOpen && (0, _agimon_ai_po_core_packageApi.poApiCallerFrom)(request.headers)?.locality !== "local") return Response.json({ error: "Opening Finder is only available on the host." }, { status: 403 });
+					const body = await request.json().catch(() => void 0);
+					const branch = typeof body === "object" && body !== null ? body.branch : void 0;
+					if (typeof branch !== "string" || !require_worktreeOperations.validRefName(branch)) return badRequest("A valid branch name is required.");
+					const repositoryRoot = await git.repositoryRoot(workspaceRoot);
+					if (repositoryRoot === void 0) return badRequest("This workspace is not a git checkout.");
+					const branches = await git.listBranches(repositoryRoot);
+					const local = branches.local.find((item) => item.name === branch);
+					if (local === void 0) return Response.json({ error: "That local branch no longer exists." }, { status: 404 });
+					if (isOpen) {
+						if (local.checkedOutAt === void 0) return Response.json({ error: "This branch has no checked-out folder." }, { status: 409 });
+						if (openDirectory === void 0) return Response.json({ error: "Finder is not available on this host." }, { status: 409 });
+						try {
+							await openDirectory(local.checkedOutAt);
+							return Response.json({ opened: true });
+						} catch {
+							return Response.json({ error: "The branch folder could not be opened in Finder." }, { status: 409 });
+						}
+					}
+					if (local.checkedOutAt !== void 0 || branches.current === branch) return Response.json({ error: "Close this branch’s worktree before deleting it." }, { status: 409 });
+					if (!await git.deleteBranch({
+						repositoryRoot,
+						branch
+					})) return Response.json({ error: "Git refused to delete this branch. It may contain unmerged commits or be checked out." }, { status: 409 });
+					return Response.json({ deleted: true });
+				}
+				const parsed = newSessionRequest(await request.json().catch(() => void 0));
+				if ("error" in parsed) return badRequest(parsed.error);
+				const record = await operations.spawn({ cwd: workspaceRoot }, {
+					branch: parsed.branch,
+					checkout: parsed.mode === "existing-branch" ? "existing" : "new",
+					...parsed.mode === "existing-branch" && parsed.remote !== void 0 ? { remote: parsed.remote } : {},
+					...parsed.mode === "new-branch" && parsed.baseRef !== void 0 ? { baseRef: parsed.baseRef } : {},
+					...parsed.name === void 0 ? {} : { name: parsed.name },
+					...parsed.selection === void 0 ? {} : { selection: parsed.selection }
+				});
+				publishLifecycle(record.sessionId, record.repositoryRoot);
+				const created = {
+					sessionId: record.sessionId,
+					worktreeId: record.id
 				};
-				return Response.json(branches);
-			}
-			const parsed = newSessionRequest(await request.json().catch(() => void 0));
-			if ("error" in parsed) return badRequest(parsed.error);
-			const record = await operations.spawn({ cwd: workspaceRoot }, {
-				branch: parsed.branch,
-				checkout: parsed.mode === "existing-branch" ? "existing" : "new",
-				...parsed.mode === "existing-branch" && parsed.remote !== void 0 ? { remote: parsed.remote } : {},
-				...parsed.mode === "new-branch" && parsed.baseRef !== void 0 ? { baseRef: parsed.baseRef } : {},
-				...parsed.name === void 0 ? {} : { name: parsed.name }
-			});
-			publishLifecycle(record.sessionId, record.repositoryRoot);
-			const created = {
-				sessionId: record.sessionId,
-				worktreeId: record.id
+				return Response.json(created, { status: 201 });
 			};
-			return Response.json(created, { status: 201 });
-		};
-		/** The admitted root for a request, or a response explaining why not. */
-		const rootOf = (url) => {
-			const repositoryId = url.searchParams.get("repositoryId");
-			if (repositoryId === null || repositoryId === "") return badRequest("A repositoryId is required.");
-			const root = context.resolveRepository?.(repositoryId);
-			if (root === void 0) return badRequest("That repository is not admitted to this cockpit.");
-			return root;
-		};
-		const homeDir = context.homeDirectory ?? node_os.default.homedir();
-		const gitAuth = createGitAuthStore(homeDir);
-		const branchDiff = createBranchDiff();
-		const pendingReviews = /* @__PURE__ */ new Map();
-		/**
-		* A workspace's remote auth. Workspace mounts only, so the step-up gate on
-		* `PUT /api/workspaces/<id>/plugins/git/auth` is the one way to write it.
-		* The view never carries the token.
-		*/
-		const auth = async (request, url) => {
-			if (url.pathname !== "/auth") return void 0;
-			if (context.scope !== "workspace") return Response.json({ error: "This route belongs to a workspace." }, { status: 404 });
-			if (request.method !== "GET" && request.method !== "PUT") return Response.json({ error: "Use GET or PUT." }, { status: 405 });
-			const root = rootOf(url);
-			if (root instanceof Response) return root;
-			if (request.method === "GET") return Response.json(gitAuth.view(root));
-			try {
-				return Response.json(gitAuth.save(root, await request.json().catch(() => void 0)));
-			} catch (error) {
-				if (error instanceof require_worktreeOperations.PoGitExpectedError && error.code === "invalid_request") {
-					const text = error.message.replace(/^\[[a-z_]+\] /u, "").replace("\nRecovery: ", " ");
-					return Response.json({
-						error: text,
-						code: error.code
-					}, { status: 400 });
-				}
-				throw error;
-			}
-		};
-		/**
-		* The session's change against its base. Session mounts only, rooted at the
-		* session's own checkout; a file is served only when it is in the change set
-		* computed for the request. Overlapping requests share an in-flight snapshot.
-		*/
-		const review = async (request, url) => {
-			if (url.pathname !== "/review" && url.pathname !== "/review/file") return void 0;
-			const cwd = context.scope === "session" ? context.cwd : void 0;
-			if (cwd === void 0) return Response.json({ error: "This route belongs to a session." }, { status: 404 });
-			if (request.method !== "GET") return Response.json({ error: "Use GET." }, { status: 405 });
-			let recordedBaseRef;
-			try {
-				recordedBaseRef = require_worktreeOperations.createWorktreeRegistry(require_worktreeOperations.registryFile(cwd, homeDir)).list().find((record) => record.sessionId === context.sessionId)?.baseRef;
-			} catch {
-				recordedBaseRef = void 0;
-			}
-			const key = JSON.stringify([cwd, recordedBaseRef ?? null]);
-			let pending = pendingReviews.get(key);
-			if (pending === void 0) {
-				pending = branchDiff.review(cwd, recordedBaseRef === void 0 ? {} : { recordedBaseRef }).finally(() => pendingReviews.delete(key));
-				pendingReviews.set(key, pending);
-			}
-			const result = await pending;
-			if (url.pathname === "/review") return Response.json(result?.summary ?? {
-				repository: false,
-				files: []
-			});
-			const filePath = url.searchParams.get("path") ?? "";
-			if (result === void 0 || !result.summary.files.some((file) => file.path === filePath)) return Response.json({ error: "That file is not part of this review." }, { status: 404 });
-			return Response.json(await branchDiff.fileDiff(result, filePath));
-		};
-		return {
-			async fetch(request) {
-				const url = new URL(request.url);
+			/** The admitted root for a request, or a response explaining why not. */
+			const rootOf = (url) => {
+				const repositoryId = url.searchParams.get("repositoryId");
+				if (repositoryId === null || repositoryId === "") return badRequest("A repositoryId is required.");
+				const root = context.resolveRepository?.(repositoryId);
+				if (root === void 0) return badRequest("That repository is not admitted to this cockpit.");
+				return root;
+			};
+			const homeDir = context.homeDirectory ?? context.environment?.HOME;
+			const gitAuth = homeDir === void 0 ? void 0 : createGitAuthStore(homeDir);
+			const branchDiff = createBranchDiff();
+			const pendingReviews = /* @__PURE__ */ new Map();
+			/**
+			* A workspace's remote auth. Workspace mounts only, so the step-up gate on
+			* `PUT /api/workspaces/<id>/plugins/git/auth` is the one way to write it.
+			* The view never carries the token.
+			*/
+			const auth = async (request, url) => {
+				if (url.pathname !== "/auth") return void 0;
+				if (context.scope !== "workspace") return Response.json({ error: "This route belongs to a workspace." }, { status: 404 });
+				if (request.method !== "GET" && request.method !== "PUT") return Response.json({ error: "Use GET or PUT." }, { status: 405 });
+				if (gitAuth === void 0) throw new Error("Git auth requires the admitted host home directory.");
+				const root = rootOf(url);
+				if (root instanceof Response) return root;
+				if (request.method === "GET") return Response.json(await gitAuth.view(root));
 				try {
-					const answered = await newSession(request, url) ?? await auth(request, url) ?? await review(request, url);
-					if (answered !== void 0) return answered;
+					return Response.json(await gitAuth.save(root, await request.json().catch(() => void 0)));
 				} catch (error) {
-					context.onNotice(`git request failed: ${error.name}`);
-					return failed(error);
+					if (error instanceof require_worktreeOperations.PoGitExpectedError && error.code === "invalid_request") {
+						const text = error.message.replace(/^\[[a-z_]+\] /u, "").replace("\nRecovery: ", " ");
+						return Response.json({
+							error: text,
+							code: error.code
+						}, { status: 400 });
+					}
+					throw error;
 				}
-				const root = rootOf(url);
-				if (root instanceof Response) return root;
-				const callerContext = {
-					cwd: root,
-					sessionId: url.searchParams.get("sessionId") ?? ""
-				};
-				if ((request.method === "POST" && url.pathname === "/worktrees" || request.method === "DELETE" && /^\/worktrees\/[^/]+$/u.test(url.pathname)) && callerContext.sessionId === "") return badRequest("A sessionId is required for worktree mutations.");
+			};
+			/**
+			* The session's change against its base. Session mounts only, rooted at the
+			* session's own checkout; a file is served only when it is in the change set
+			* computed for the request. Overlapping requests share an in-flight snapshot.
+			*/
+			const review = async (request, url) => {
+				if (url.pathname !== "/review" && url.pathname !== "/review/file") return void 0;
+				const cwd = context.scope === "session" ? context.cwd : void 0;
+				if (cwd === void 0) return Response.json({ error: "This route belongs to a session." }, { status: 404 });
+				if (request.method !== "GET") return Response.json({ error: "Use GET." }, { status: 405 });
+				if (homeDir === void 0) throw new Error("Git review requires the admitted host home directory.");
+				let recordedBaseRef;
 				try {
-					if (request.method === "GET" && url.pathname === "/worktrees") return Response.json({ worktrees: await operations.list(callerContext) });
-					if (request.method === "POST" && url.pathname === "/worktrees") {
-						const body = await request.json();
-						if (typeof body.branch !== "string" || body.branch.trim() === "") return badRequest("A branch is required.");
-						const record = await operations.spawn(callerContext, {
-							branch: body.branch,
-							...body.baseRef === void 0 ? {} : { baseRef: body.baseRef },
-							...body.name === void 0 ? {} : { name: body.name }
-						});
-						publishLifecycle(callerContext.sessionId, record.repositoryRoot);
-						return Response.json({ worktree: record }, { status: 201 });
+					recordedBaseRef = (await require_worktreeOperations.createWorktreeRegistry(await require_worktreeOperations.registryFile(cwd, homeDir)).list()).find((record) => record.sessionId === context.sessionId)?.baseRef;
+				} catch {
+					recordedBaseRef = void 0;
+				}
+				const key = JSON.stringify([cwd, recordedBaseRef ?? null]);
+				let pending = pendingReviews.get(key);
+				if (pending === void 0) {
+					pending = branchDiff.review(cwd, recordedBaseRef === void 0 ? {} : { recordedBaseRef }).finally(() => pendingReviews.delete(key));
+					pendingReviews.set(key, pending);
+				}
+				const result = await pending;
+				if (url.pathname === "/review") return Response.json(result?.summary ?? {
+					repository: false,
+					files: []
+				});
+				const filePath = url.searchParams.get("path") ?? "";
+				if (result === void 0 || !result.summary.files.some((file) => file.path === filePath)) return Response.json({ error: "That file is not part of this review." }, { status: 404 });
+				return Response.json(await branchDiff.fileDiff(result, filePath));
+			};
+			return {
+				async fetch(request) {
+					const url = new URL(request.url);
+					try {
+						const answered = await newSession(request, url) ?? await auth(request, url) ?? await review(request, url);
+						if (answered !== void 0) return answered;
+					} catch (error) {
+						context.onNotice(`git request failed: ${error.name}`);
+						return failed(error);
 					}
-					const closing = /^\/worktrees\/([^/]+)$/u.exec(url.pathname);
-					if (request.method === "DELETE" && closing) {
-						const record = await operations.close(callerContext, decodeURIComponent(String(closing[1])), url.searchParams.get("force") === "true");
-						publishLifecycle(callerContext.sessionId, record.repositoryRoot);
-						return Response.json({ worktree: record });
+					const root = rootOf(url);
+					if (root instanceof Response) return root;
+					const callerContext = {
+						cwd: root,
+						sessionId: url.searchParams.get("sessionId") ?? ""
+					};
+					if ((request.method === "POST" && url.pathname === "/worktrees" || request.method === "DELETE" && /^\/worktrees\/[^/]+$/u.test(url.pathname)) && callerContext.sessionId === "") return badRequest("A sessionId is required for worktree mutations.");
+					try {
+						if (request.method === "GET" && url.pathname === "/worktrees") return Response.json({ worktrees: await operations.list(callerContext) });
+						if (request.method === "POST" && url.pathname === "/worktrees") {
+							const body = await request.json();
+							if (typeof body.branch !== "string" || body.branch.trim() === "") return badRequest("A branch is required.");
+							const record = await operations.spawn(callerContext, {
+								branch: body.branch,
+								...body.baseRef === void 0 ? {} : { baseRef: body.baseRef },
+								...body.name === void 0 ? {} : { name: body.name }
+							});
+							publishLifecycle(callerContext.sessionId, record.repositoryRoot);
+							return Response.json({ worktree: record }, { status: 201 });
+						}
+						const closing = /^\/worktrees\/([^/]+)$/u.exec(url.pathname);
+						if (request.method === "DELETE" && closing) {
+							const record = await operations.close(callerContext, decodeURIComponent(String(closing[1])), url.searchParams.get("force") === "true");
+							publishLifecycle(callerContext.sessionId, record.repositoryRoot);
+							return Response.json({ worktree: record });
+						}
+						return Response.json({ error: "No such worktree route." }, { status: 404 });
+					} catch (error) {
+						context.onNotice(`worktree request failed: ${error.name}`);
+						return failed(error);
 					}
-					return Response.json({ error: "No such worktree route." }, { status: 404 });
-				} catch (error) {
-					context.onNotice(`worktree request failed: ${error.name}`);
-					return failed(error);
-				}
-			},
-			close() {}
+				},
+				close() {}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/api/git/route.server.ts
+var route_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoute)(({ context, host, signal }) => {
+	let openDirectory;
+	context.inject([_agimon_ai_po_core_platform.PO_SHELL_SERVICE], (child) => {
+		const shell = (0, _agimon_ai_po_core_platform.requirePoShell)(child);
+		const env = Object.fromEntries(Object.entries(host.context.environment ?? {}).filter((entry) => entry[1] !== void 0));
+		openDirectory = async (path) => {
+			const result = await shell.exec([
+				"/usr/bin/open",
+				"-a",
+				"Finder",
+				path
+			], {
+				env,
+				inheritEnv: false
+			}, (0, _agimon_ai_po_core_platform.withAbortSignal)(AbortSignal.any([signal, AbortSignal.timeout(5e3)]), _agimon_ai_po_core_platform.BACKGROUND_CONTEXT));
+			if (!result.ok || result.value.exitCode !== 0) throw new Error("Finder could not be opened.");
 		};
-	}
+		return () => {
+			openDirectory = void 0;
+		};
+	});
+	return createGitApi(async (path) => {
+		if (openDirectory === void 0) throw new Error("The host shell is unavailable.");
+		await openDirectory(path);
+	});
 });
 //#endregion
 //#region src/services/gitFailure/index.ts
@@ -1420,7 +1668,7 @@ async function rebasing(root) {
 			"--git-path",
 			name
 		]);
-		if (gitPath !== void 0 && node_fs.default.existsSync(node_path.default.resolve(root, gitPath))) return true;
+		if (gitPath !== void 0 && await node_fs_promises.default.access(node_path.default.resolve(root, gitPath)).then(() => true, () => false)) return true;
 	}
 	return false;
 }
@@ -1590,9 +1838,9 @@ const GIT_CHANGES_TYPE = "git_changes";
 * DESIGN PATTERNS:
 * - Apart from the worktrees channel. Worktrees are repository management;
 *   this is the session's own code change.
-* - Push, not poll. The session facet publishes a "changed" event after every
-*   tool call and settled turn; recounts are coalesced to one in flight plus
-*   one rerun, so a burst of tool calls costs at most two.
+* - Push, not poll. The session's server plugin publishes a "changed" event
+*   after every tool call and settled turn; recounts are coalesced to one in
+*   flight plus one rerun, so a burst of tool calls costs at most two.
 * - One sync command per session. A rebase and a push must never overlap.
 * - Auth is read fresh for each command from the session's workspace, and goes
 *   only into that command's git child.
@@ -1653,9 +1901,9 @@ function createGitChangesChannel(options = {}) {
 			const rerun = /* @__PURE__ */ new Set();
 			const busy = /* @__PURE__ */ new Set();
 			/** The base the session's own worktree was created from, when it has one. */
-			const recordedBaseRef = (scope) => {
+			const recordedBaseRef = async (scope) => {
 				try {
-					return require_worktreeOperations.createWorktreeRegistry(require_worktreeOperations.registryFile(scope.cwd, homeDir)).list().find((record) => record.sessionId === scope.sessionId)?.baseRef;
+					return (await require_worktreeOperations.createWorktreeRegistry(await require_worktreeOperations.registryFile(scope.cwd, homeDir)).list()).find((record) => record.sessionId === scope.sessionId)?.baseRef;
 				} catch {
 					return;
 				}
@@ -1688,8 +1936,7 @@ function createGitChangesChannel(options = {}) {
 					return;
 				}
 				inFlight.add(sessionId);
-				const base = recordedBaseRef(scope);
-				diff.review(scope.cwd, base === void 0 ? {} : { recordedBaseRef: base }).then((review) => {
+				recordedBaseRef(scope).then((base) => diff.review(scope.cwd, base === void 0 ? {} : { recordedBaseRef: base })).then((review) => {
 					if (scopes.has(sessionId)) update(sessionId, { changes: review?.changes });
 				}).catch((error) => {
 					host.onNotice(`git diff refresh failed for ${sessionId} (${error instanceof Error ? error.name : "unknown"})`);
@@ -1698,12 +1945,12 @@ function createGitChangesChannel(options = {}) {
 					if (rerun.delete(sessionId)) refresh(sessionId);
 				});
 			};
-			const run = (scope, command) => {
+			const run = async (scope, command) => {
 				const workspaceRoot = scope.sessionContext?.workspaceRoot ?? scope.cwd;
-				const base = recordedBaseRef(scope);
+				const base = await recordedBaseRef(scope);
 				const context = {
 					cwd: scope.cwd,
-					auth: auth.read(workspaceRoot),
+					auth: await auth.read(workspaceRoot),
 					...base === void 0 ? {} : { recordedBaseRef: base }
 				};
 				if (command.action === "pull") return sync.pull(context);
@@ -1801,9 +2048,9 @@ function payloadOf(state) {
 	};
 }
 /** Worktrees visible to this session, using the hub's live session table for ownership. */
-function viewsFor(scope, deps) {
+async function viewsFor(scope, deps) {
 	try {
-		return require_worktreeOperations.createWorktreeRegistry(require_worktreeOperations.registryFile(scope.cwd, deps.homeDir)).list().flatMap((record) => {
+		return (await require_worktreeOperations.createWorktreeRegistry(await require_worktreeOperations.registryFile(scope.cwd, deps.homeDir)).list()).flatMap((record) => {
 			if (record.parentSessionId === void 0 && record.sessionId !== scope.sessionId) return [];
 			const owned = record.parentSessionId === void 0 || record.parentSessionId === scope.sessionId;
 			const unowned = !owned && !deps.sessionService.isLive(record.parentSessionId);
@@ -1828,11 +2075,15 @@ function sameList(left, right) {
 		return other !== void 0 && entry.id === other.id && entry.branch === other.branch && entry.sessionId === other.sessionId && entry.orphaned === other.orphaned && entry.unowned === other.unowned;
 	});
 }
-function errorTargetFor(command) {
-	return command.action === "create" ? { action: "create" } : {
+function errorTargetFor(command, error) {
+	if (command.action === "close") return {
 		action: "close",
 		id: command.id
 	};
+	return error instanceof require_worktreeOperations.PoGitExpectedError && error.code === "rift_missing" ? {
+		action: "create",
+		riftMissing: true
+	} : { action: "create" };
 }
 /** A command the page sent, or undefined when the frame was not one. */
 function parseCommand(payload) {
@@ -1860,11 +2111,15 @@ function parseCommand(payload) {
 /**
 * What the reader is told when a command fails.
 *
-* An expected failure explains itself. Anything else is summarised, never
-* echoed: a git error can carry a remote URL with a token in it.
+* An expected failure explains itself, minus the `[code]` tag and recovery line
+* written for the agent's tool result. A dirty close is said in the person's
+* terms, because its message tells the agent to pass `force`. Anything else is
+* summarised, never echoed: a git error can carry a remote URL with a token in it.
 */
 function failureText(error) {
-	return error instanceof require_worktreeOperations.PoGitExpectedError ? error.message : "The worktree operation failed.";
+	if (!(error instanceof require_worktreeOperations.PoGitExpectedError)) return "The worktree operation failed.";
+	if (error.code === "worktree_dirty") return "The worktree has uncommitted changes.";
+	return error.message.replace(/^\[[a-z_]+\] /u, "").split("\nRecovery:")[0] ?? error.message;
 }
 /** Starts one direct-event subscription per managed session. */
 function createWorktreesChannel(options = {}) {
@@ -1917,10 +2172,13 @@ function createWorktreesChannel(options = {}) {
 				return generation;
 			};
 			/** Republishes a session, skipping a frame that would say nothing new. */
-			const publish = (scope, force) => {
+			const publish = async (scope, force) => {
+				const generation = generations.get(scope.sessionId);
+				const worktreeViews = await viewsFor(scope, views);
+				if (generation === void 0 || generations.get(scope.sessionId) !== generation) return;
 				const previous = latest.get(scope.sessionId);
 				const next = {
-					worktrees: viewsFor(scope, views),
+					worktrees: worktreeViews,
 					pending: previous?.pending,
 					error: previous?.error,
 					errorTarget: previous?.errorTarget
@@ -1932,7 +2190,7 @@ function createWorktreesChannel(options = {}) {
 			const mark = (scope, pending, error, errorTarget) => {
 				const previous = latest.get(scope.sessionId);
 				latest.set(scope.sessionId, {
-					worktrees: previous?.worktrees ?? viewsFor(scope, views),
+					worktrees: previous?.worktrees ?? [],
 					pending,
 					error,
 					errorTarget
@@ -1972,15 +2230,15 @@ function createWorktreesChannel(options = {}) {
 				sessionAdded(scope) {
 					newGeneration(scope.sessionId);
 					publish(scope, false);
-					const unsubscribe = host.directEvents.subscribe(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, scope.sessionId, (payload) => {
+					const unsubscribe = host.directEvents.subscribe(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, scope.sessionId, async (payload) => {
 						if (!require_worktreeOperations.isWorktreeLifecycleEvent(payload)) return;
 						let sameRepository = false;
 						try {
-							sameRepository = require_worktreeOperations.registryFile(scope.cwd, options.homeDir) === require_worktreeOperations.registryFile(payload.repositoryRoot, options.homeDir);
+							sameRepository = await require_worktreeOperations.registryFile(scope.cwd, options.homeDir) === await require_worktreeOperations.registryFile(payload.repositoryRoot, options.homeDir);
 						} catch {
 							sameRepository = false;
 						}
-						if (sameRepository) publish(scope, false);
+						if (sameRepository) await publish(scope, false);
 					});
 					subscriptions.set(scope.sessionId, unsubscribe);
 				},
@@ -2013,7 +2271,7 @@ function createWorktreesChannel(options = {}) {
 				}).catch((error) => {
 					if (generations.get(scope.sessionId) !== generation) return;
 					host.onNotice(`worktree command failed for ${scope.sessionId} (${failureText(error)})`);
-					mark(scope, void 0, failureText(error), errorTargetFor(command));
+					mark(scope, void 0, failureText(error), errorTargetFor(command, error));
 				}).finally(() => {
 					if (generations.get(scope.sessionId) === generation) busy.delete(scope.sessionId);
 				});
@@ -2035,20 +2293,8 @@ var agent_settled_server_default = (0, _agimon_ai_po_core_extensionFile.defineHo
 //#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
 var tool_execution_end_server_default = (0, _agimon_ai_po_core_extensionFile.defineHook)((context) => context.root.hooks[0]);
 //#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/poGit.server.ts
-var poGit_server_default$1 = (context) => context.root.resources[0];
-//#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/poGit.server.ts
-var poGit_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)(poGit_server_default$1);
-//#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/poGitReadme.server.ts
-var poGitReadme_server_default$1 = (context) => context.root.resources[2];
-//#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/poGitReadme.server.ts
-var poGitReadme_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)(poGitReadme_server_default$1);
-//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/resource/_lib/poUseGit.server.ts
-var poUseGit_server_default$1 = (context) => context.root.resources[1];
+var poUseGit_server_default$1 = (context) => context.root.resources[0];
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/resource/poUseGit.server.ts
 var poUseGit_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)(poUseGit_server_default$1);
@@ -2058,19 +2304,22 @@ var runWorktree_server_default = (0, _agimon_ai_po_core_extensionFile.defineServ
 //#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
 const via = (identity, value) => value === void 0 ? void 0 : {
 	...identity,
 	...value
 };
-const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
+const serverPlugin = (0, _agimon_ai_po_core_serverPlugin.defineServerPlugin)({
 	name: "@agimon-ai/po-git",
-	providerOverrides: (0, _agimon_ai_po_core_serverFacet.composeServerProviderOverrides)(root_server_default),
+	providerOverrides: (0, _agimon_ai_po_core_serverPlugin.composeServerProviderOverrides)(root_server_default),
+	injects: (0, _agimon_ai_po_core_extensionFile.composeRootInjects)({ session: [root_server_default] }),
 	global: (context) => ({
 		get api() {
 			return [at(route_server_default, context)];
 		},
 		get channels() {
-			return [() => via({ frameType: "git_changes" }, git_changes_server_default()), () => via({ frameType: "git_worktrees" }, git_worktrees_server_default())];
+			return [() => via({ frameType: "git_changes" }, at(git_changes_server_default, context)), () => via({ frameType: "git_worktrees" }, at(git_worktrees_server_default, context))];
 		}
 	}),
 	workspace: (context) => ({
@@ -2078,11 +2327,11 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 			return [at(route_server_default, context)];
 		},
 		get channels() {
-			return [() => via({ frameType: "git_changes" }, git_changes_server_default()), () => via({ frameType: "git_worktrees" }, git_worktrees_server_default())];
+			return defined([context.hosted("global") ? void 0 : () => via({ frameType: "git_changes" }, at(git_changes_server_default, context)), context.hosted("global") ? void 0 : () => via({ frameType: "git_worktrees" }, at(git_worktrees_server_default, context))]);
 		}
 	}),
 	session: async (context) => {
-		const scopeSession = await root_server_default(context);
+		const scopeSession = await context.scopeRoot("session", root_server_default, context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
@@ -2093,17 +2342,13 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 				return [at(route_server_default, context)];
 			},
 			get channels() {
-				return [() => via({ frameType: "git_changes" }, git_changes_server_default()), () => via({ frameType: "git_worktrees" }, git_worktrees_server_default())];
+				return defined([context.hosted("global") ? void 0 : () => via({ frameType: "git_changes" }, at(git_changes_server_default, context)), context.hosted("global") ? void 0 : () => via({ frameType: "git_worktrees" }, at(git_worktrees_server_default, context))]);
 			},
 			get hooks() {
 				return [via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)), via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession))];
 			},
 			get resources() {
-				return [
-					at(poGit_server_default, contextSession),
-					at(poGitReadme_server_default, contextSession),
-					at(poUseGit_server_default, contextSession)
-				];
+				return [at(poUseGit_server_default, contextSession)];
 			},
 			get tools() {
 				return [via({ name: "run_worktree" }, at(runWorktree_server_default, contextSession))];
@@ -2116,7 +2361,7 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 	}
 });
 //#endregion
-exports.default = facet;
-exports.facet = facet;
+exports.default = serverPlugin;
+exports.serverPlugin = serverPlugin;
 
 //# sourceMappingURL=server.cjs.map