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

package/dist/extensions/server.cjs

@@ -2,15 +2,16 @@ 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-CD7s0YnO.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");
 //#region src/schemas/runWorktreeTool.ts
@@ -254,7 +255,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 +280,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 +298,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 +474,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 +487,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 +512,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 +653,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 +666,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 +789,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 +798,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 +856,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 +864,7 @@ function createBranchDiff() {
 						rows: [{
 							marker: "+",
 							line: 1,
-							content: node_fs.default.readlinkSync(absolute)
+							content: await node_fs_promises.default.readlink(absolute)
 						}]
 					}]
 				};
@@ -694,7 +873,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 +990,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 +1041,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 +1051,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 +1086,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 +1106,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);
 		}
 	};
@@ -1194,9 +1373,9 @@ var route_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoute)({
 			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));
+			if (request.method === "GET") return Response.json(await gitAuth.view(root));
 			try {
-				return Response.json(gitAuth.save(root, await request.json().catch(() => void 0)));
+				return Response.json(await 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: ", " ");
@@ -1220,7 +1399,7 @@ var route_server_default = (0, _agimon_ai_po_core_extensionFile.defineRoute)({
 			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;
+				recordedBaseRef = (await require_worktreeOperations.createWorktreeRegistry(await require_worktreeOperations.registryFile(cwd, homeDir)).list()).find((record) => record.sessionId === context.sessionId)?.baseRef;
 			} catch {
 				recordedBaseRef = void 0;
 			}
@@ -1420,7 +1599,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 +1769,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 +1832,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 +1867,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 +1876,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 +1979,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 +2006,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 +2042,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 +2103,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 +2121,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 +2161,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 +2202,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 +2224,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 +2235,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 +2258,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 +2273,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 +2292,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