@agimon-ai/doompi-git 0.0.1-alpha.5 → 0.0.1-alpha.50

package/dist/extensions/server.cjs

@@ -0,0 +1,1828 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_worktreeOperations = require("../worktreeOperations-BYmVU0UV.cjs");
+const require_runWorktree = require("../runWorktree-BE795LxL.cjs");
+let node_fs = require("node:fs");
+node_fs = require_worktreeOperations.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_worktreeOperations.__toESM(node_path, 1);
+let node_os = require("node:os");
+node_os = require_worktreeOperations.__toESM(node_os, 1);
+let _agimon_ai_doompi_core_extensionFile = require("@agimon-ai/doompi-core/extensionFile");
+let _agimon_ai_doompi_core_serverFacet = require("@agimon-ai/doompi-core/serverFacet");
+let _agimon_ai_doompi_session = require("@agimon-ai/doompi-session");
+//#region src/extensions/workspaces/sessions/(backend)/_lib/root.server.ts
+function progressResult(action, label) {
+	return {
+		content: [{
+			type: "text",
+			text: 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.");
+	const sessionId = serverHost.context.sessionId;
+	const directEvents = serverHost.context.directEvents;
+	const messageInbox = require_worktreeOperations.createWorktreeMessageInbox(directEvents, sessionId);
+	const operations = require_worktreeOperations.createWorktreeOperations({
+		git: require_worktreeOperations.createWorktreeGit(),
+		sessionService: serverHost.context.sessionService,
+		messageInbox,
+		sessionDelivery: () => (0, _agimon_ai_doompi_session.readDoomSessionDelivery)(context)
+	});
+	const resources = [{
+		when: {
+			state: { "minor-mode": "help" },
+			attribution: {
+				kind: "minor",
+				mode: "help"
+			}
+		},
+		name: "doompi-git",
+		kind: "context",
+		read: () => (0, _agimon_ai_doompi_core_serverFacet.readPackageResource)(require("url").pathToFileURL(__filename).href, "llms.txt")
+	}, {
+		name: "doompi-use-git",
+		kind: "skill",
+		read: () => (0, _agimon_ai_doompi_core_serverFacet.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/doompi-use-git/SKILL.md")
+	}];
+	const tool = {
+		name: require_runWorktree.RUN_WORKTREE_TOOL_NAME,
+		label: "Worktree",
+		description: require_runWorktree.RUN_WORKTREE_DESCRIPTION,
+		parameters: require_runWorktree.RunWorktreeToolSchema,
+		promptSnippet: "Create and manage Git worktree sessions",
+		executionMode: "serial",
+		async execute(_toolCallId, parameters, signal, onUpdate, execution) {
+			const params = require_runWorktree.validateParams(parameters);
+			return require_runWorktree.executeRunWorktreeTool(params, operations, execution, {
+				...signal === void 0 ? {} : { signal },
+				onProgress: (label) => onUpdate?.(progressResult(params.action, label))
+			});
+		}
+	};
+	const changed = (_event, execution) => {
+		directEvents.publish(require_worktreeOperations.GIT_SESSION_CHANGED_EVENT, execution.sessionId, { version: 1 });
+	};
+	return {
+		value: {
+			resources,
+			tool,
+			hooks: [{
+				event: "tool_execution_end",
+				handle: changed
+			}, {
+				event: "agent_settled",
+				handle: changed
+			}]
+		},
+		onDispose: () => messageInbox.close()
+	};
+}
+const root = (0, _agimon_ai_doompi_core_extensionFile.defineRoot)(createGitSession);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineRoot)(root);
+//#endregion
+//#region src/services/branchDiff/index.ts
+/**
+* What a session's checkout changed against its base, the way a pull request
+* shows it: every commit since the branch left its base, plus staged, unstaged
+* and untracked work.
+*
+* DESIGN PATTERNS:
+* - git computes every diff. The counts come from `--numstat` and the hunks
+*   from the same unified diff, so the two always agree.
+* - The base is the worktree's own recorded base when there is one, then the
+*   remote's default branch, then the branch's upstream, and with none of those
+*   only uncommitted work counts. It is always named in the UI.
+* - Untracked files are read only when they are small regular files; a symlink
+*   shows its link text and is never followed.
+*
+* AVOID:
+* - Passing a browser path to git without checking it against the change set.
+*/
+/** git's well-known empty tree, the base of a repository with no commits. */
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+const MAX_LISTED_FILES = 500;
+const MAX_UNTRACKED_COUNTED = 200;
+const MAX_FILE_BYTES = 1048576;
+const MAX_ROWS = 5e3;
+const BINARY_PROBE_BYTES = 8192;
+const SHORT_SHA = 7;
+const DEFAULT_BRANCHES = ["main", "master"];
+async function read(cwd, args) {
+	const result = await require_worktreeOperations.runGit(cwd, args, { timeout: require_worktreeOperations.READ_TIMEOUT_MS });
+	return result.code === 0 ? result.stdout : void 0;
+}
+async function readLine$1(cwd, args) {
+	const out = (await read(cwd, args))?.trim();
+	return out === void 0 || out === "" ? void 0 : out;
+}
+async function commitExists(cwd, ref) {
+	return await readLine$1(cwd, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`${ref}^{commit}`
+	]) !== void 0;
+}
+/** A local branch's upstream, so the review measures against what fetch keeps current. */
+async function upstreamOf(cwd, ref) {
+	return readLine$1(cwd, [
+		"rev-parse",
+		"--abbrev-ref",
+		"--symbolic-full-name",
+		`${ref}@{upstream}`
+	]);
+}
+/** The ref the review is measured against. Exported for sync, whose rebase uses the same base. */
+async function resolveBaseRef(cwd, branch, recordedBaseRef) {
+	if (!(recordedBaseRef === void 0 || branch !== void 0 && (recordedBaseRef === branch || recordedBaseRef.endsWith(`/${branch}`))) && recordedBaseRef !== void 0 && await commitExists(cwd, recordedBaseRef)) return (await readLine$1(cwd, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`refs/heads/${recordedBaseRef}`
+	]) !== void 0 ? await upstreamOf(cwd, recordedBaseRef) : void 0) ?? recordedBaseRef;
+	const originHead = await readLine$1(cwd, [
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"refs/remotes/origin/HEAD"
+	]);
+	if (originHead !== void 0) return originHead;
+	for (const name of DEFAULT_BRANCHES) if (await commitExists(cwd, `origin/${name}`)) return `origin/${name}`;
+	return branch === void 0 ? void 0 : upstreamOf(cwd, branch);
+}
+async function resolveBase(cwd, branch, recordedBaseRef) {
+	const ref = await resolveBaseRef(cwd, branch, recordedBaseRef);
+	const head = await commitExists(cwd, "HEAD");
+	if (ref !== void 0 && head) {
+		const mergeBase = await readLine$1(cwd, [
+			"merge-base",
+			ref,
+			"HEAD"
+		]);
+		if (mergeBase !== void 0) return {
+			ref,
+			from: mergeBase,
+			mergeBase: mergeBase.slice(0, SHORT_SHA)
+		};
+	}
+	return { from: head ? "HEAD" : EMPTY_TREE };
+}
+/** NUL-separated fields from a `-z` listing, without the trailing empty one. */
+function zFields(out) {
+	if (out === void 0 || out === "") return [];
+	const fields = out.split("\0");
+	if (fields.at(-1) === "") fields.pop();
+	return fields;
+}
+const NAME_STATUS = {
+	A: "added",
+	D: "deleted",
+	M: "modified",
+	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) {
+	const absolute = node_path.default.join(root, relPath);
+	let stat;
+	try {
+		stat = node_fs.default.lstatSync(absolute);
+	} catch {
+		return;
+	}
+	if (stat.isSymbolicLink()) return {
+		lines: 1,
+		binary: false
+	};
+	if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return void 0;
+	const content = node_fs.default.readFileSync(absolute);
+	if (content.subarray(0, BINARY_PROBE_BYTES).includes(0)) return {
+		lines: 0,
+		binary: true
+	};
+	if (content.length === 0) return {
+		lines: 0,
+		binary: false
+	};
+	const text = content.toString("utf8");
+	const newlines = text.split("\n").length - 1;
+	return {
+		lines: text.endsWith("\n") ? newlines : newlines + 1,
+		binary: false
+	};
+}
+/** The hunks of a unified diff, numbering each row by the file it lives in. */
+function parseUnifiedDiff(diff) {
+	const hunks = [];
+	let current;
+	let oldLine = 0;
+	let newLine = 0;
+	let rows = 0;
+	let binary = false;
+	for (const line of diff.split("\n")) {
+		const header = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/u.exec(line);
+		if (header !== null) {
+			oldLine = Number(header[1]);
+			newLine = Number(header[2]);
+			current = {
+				start: newLine,
+				rows: []
+			};
+			hunks.push(current);
+			continue;
+		}
+		if (current === void 0) {
+			if (line.startsWith("Binary files ") || line === "GIT binary patch") binary = true;
+			continue;
+		}
+		const marker = line[0];
+		let row;
+		if (marker === " ") row = {
+			marker: " ",
+			line: newLine,
+			content: line.slice(1)
+		};
+		else if (marker === "-") row = {
+			marker: "-",
+			line: oldLine,
+			content: line.slice(1)
+		};
+		else if (marker === "+") row = {
+			marker: "+",
+			line: newLine,
+			content: line.slice(1)
+		};
+		if (row === void 0) continue;
+		if (marker !== "+") oldLine += 1;
+		if (marker !== "-") newLine += 1;
+		current.rows.push(row);
+		rows += 1;
+	}
+	return {
+		hunks,
+		binary,
+		rows
+	};
+}
+function createBranchDiff() {
+	return {
+		async review(cwd, options = {}) {
+			const root = await readLine$1(cwd, ["rev-parse", "--show-toplevel"]);
+			if (root === void 0) return void 0;
+			const branch = await readLine$1(root, [
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				"HEAD"
+			]);
+			const base = await resolveBase(root, branch, options.recordedBaseRef);
+			const numstat = zFields(await read(root, [
+				"diff",
+				"--numstat",
+				"-z",
+				"--no-renames",
+				base.from
+			]));
+			const nameStatus = zFields(await read(root, [
+				"diff",
+				"--name-status",
+				"-z",
+				"--no-renames",
+				base.from
+			]));
+			const unmerged = new Set(zFields(await read(root, [
+				"diff",
+				"--name-only",
+				"--diff-filter=U",
+				"-z"
+			])));
+			const statusOf = /* @__PURE__ */ new Map();
+			for (let index = 0; index + 1 < nameStatus.length; index += 2) statusOf.set(nameStatus[index + 1] ?? "", NAME_STATUS[(nameStatus[index] ?? "").charAt(0)] ?? "modified");
+			const entries = [];
+			for (const field of numstat) {
+				const [added = "", removed = "", ...rest] = field.split("	");
+				const filePath = rest.join("	");
+				if (filePath === "") continue;
+				const binary = added === "-" && removed === "-";
+				entries.push({
+					path: filePath,
+					status: unmerged.has(filePath) ? "conflicted" : statusOf.get(filePath) ?? "modified",
+					added: binary ? 0 : Number(added),
+					removed: binary ? 0 : Number(removed),
+					...binary ? { binary: true } : {}
+				});
+			}
+			const untracked = zFields(await read(root, [
+				"ls-files",
+				"--others",
+				"--exclude-standard",
+				"-z"
+			]));
+			untracked.forEach((relPath, index) => {
+				const counted = index < MAX_UNTRACKED_COUNTED ? untrackedLines(root, relPath) : void 0;
+				entries.push({
+					path: relPath,
+					status: "untracked",
+					added: counted?.lines ?? 0,
+					removed: 0,
+					...counted?.binary ? { binary: true } : {}
+				});
+			});
+			entries.sort((left, right) => left.path.localeCompare(right.path));
+			const conflicts = [...unmerged];
+			const rebasing = [await readLine$1(root, [
+				"rev-parse",
+				"--git-path",
+				"rebase-merge"
+			]), 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 upstreamRef = branch === void 0 ? void 0 : await upstreamOf(root, branch);
+			let upstream;
+			if (upstreamRef !== void 0) {
+				const [behind, ahead] = (await readLine$1(root, [
+					"rev-list",
+					"--left-right",
+					"--count",
+					`${upstreamRef}...HEAD`
+				]) ?? "").split(/\s+/u).map(Number);
+				if (Number.isInteger(ahead) && Number.isInteger(behind)) upstream = {
+					ref: upstreamRef,
+					ahead,
+					behind
+				};
+			}
+			const truncated = entries.length > MAX_LISTED_FILES || untracked.length > MAX_UNTRACKED_COUNTED;
+			return {
+				root,
+				base,
+				changes: {
+					added: entries.reduce((sum, entry) => sum + entry.added, 0),
+					removed: entries.reduce((sum, entry) => sum + entry.removed, 0),
+					files: entries.length,
+					...branch === void 0 ? {} : { branch },
+					...base.ref === void 0 ? {} : { base: base.ref },
+					...truncated ? { truncated: true } : {},
+					...upstream === void 0 ? {} : { upstream },
+					...rebasing ? { rebase: { conflicts } } : {}
+				},
+				summary: {
+					repository: true,
+					files: entries.slice(0, MAX_LISTED_FILES),
+					...branch === void 0 ? {} : { branch },
+					...base.ref === void 0 ? {} : { base: base.ref },
+					...base.mergeBase === void 0 ? {} : { mergeBase: base.mergeBase },
+					...truncated ? { truncated: true } : {}
+				}
+			};
+		},
+		async fileDiff(review, filePath) {
+			const entry = review.summary.files.find((file) => file.path === filePath);
+			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);
+				if (stat.isSymbolicLink()) return {
+					path: entry.path,
+					hunks: [{
+						start: 1,
+						rows: [{
+							marker: "+",
+							line: 1,
+							content: node_fs.default.readlinkSync(absolute)
+						}]
+					}]
+				};
+				if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return {
+					path: entry.path,
+					hunks: [],
+					tooLarge: true
+				};
+				const content = node_fs.default.readFileSync(absolute);
+				if (content.subarray(0, BINARY_PROBE_BYTES).includes(0)) return {
+					path: entry.path,
+					hunks: [],
+					binary: true
+				};
+				const lines = content.toString("utf8").split("\n");
+				if (lines.at(-1) === "") lines.pop();
+				if (lines.length > MAX_ROWS) return {
+					path: entry.path,
+					hunks: [],
+					tooLarge: true
+				};
+				return {
+					path: entry.path,
+					hunks: lines.length === 0 ? [] : [{
+						start: 1,
+						rows: lines.map((content, index) => ({
+							marker: "+",
+							line: index + 1,
+							content
+						}))
+					}]
+				};
+			}
+			const result = await require_worktreeOperations.runGit(review.root, [
+				"diff",
+				"-U3",
+				"--no-color",
+				"--no-ext-diff",
+				"--no-textconv",
+				"--no-renames",
+				review.base.from,
+				"--",
+				`:(top,literal)${entry.path}`
+			], {
+				timeout: require_worktreeOperations.READ_TIMEOUT_MS,
+				maxBuffer: MAX_FILE_BYTES
+			});
+			if (result.overflow) return {
+				path: entry.path,
+				hunks: [],
+				tooLarge: true
+			};
+			if (result.code !== 0) throw new Error(`git diff failed (exit ${String(result.code)}).`);
+			const parsed = parseUnifiedDiff(result.stdout);
+			if (parsed.binary || entry.binary === true) return {
+				path: entry.path,
+				hunks: [],
+				binary: true
+			};
+			if (parsed.rows > MAX_ROWS) return {
+				path: entry.path,
+				hunks: [],
+				tooLarge: true
+			};
+			return {
+				path: entry.path,
+				hunks: parsed.hunks
+			};
+		}
+	};
+}
+//#endregion
+//#region src/services/gitAuth/index.ts
+/**
+* Per-workspace remote auth for doompi-git's own fetch, pull, push and rebase.
+*
+* DESIGN PATTERNS:
+* - One file outside every repository, folder 0700 and file 0600, repaired on
+*   read if something loosened it. The token never leaves this module except
+*   into the environment of one git child process.
+* - Config reaches git through GIT_CONFIG_COUNT environment entries, never
+*   argv, so nothing secret shows in `ps`. The first entry empties the
+*   credential helper list, which is what keeps macOS's osxkeychain helper from
+*   storing the token after a successful push.
+* - The token is offered only to the host it was entered for. A repository
+*   whose remote points anywhere else gets this machine's own credentials.
+*
+* AVOID:
+* - Touching process.env. The hub runs every session; anything set there
+*   would reach the agent's shell, which the user ruled out.
+*/
+const OWNER_ONLY_DIRECTORY = 448;
+const OWNER_ONLY_FILE = 384;
+const LOOSE_BITS = 63;
+const HOST_PATTERN = /^[a-z0-9.-]{1,253}(:\d{1,5})?$/u;
+const MAX_USERNAME = 256;
+const MAX_TOKEN = 4096;
+const SETTINGS_HINT = "Open settings, then repository, then git remote.";
+/** Environment that would make git log or skip what this module relies on. */
+const STRIPPED_ALWAYS = ["GIT_CURL_VERBOSE", "GIT_TRACE_REDACT"];
+const STRIPPED_PREFIXES = ["GIT_TRACE"];
+/** Environment that could redirect or override credentials when the workspace's own are in play. */
+const STRIPPED_CREDENTIALED = [
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_CONFIG_COUNT",
+	"GIT_SSL_NO_VERIFY",
+	"SSH_ASKPASS",
+	"GIT_SSH",
+	"GIT_SSH_COMMAND"
+];
+const CONFIG_ENTRY = /^GIT_CONFIG_(KEY|VALUE)_\d+$/u;
+/** The inline helper: answers `get` from this child's environment, and ignores `store` and `erase`. */
+const ENV_CREDENTIAL_HELPER = "!f(){ test \"$1\" = get && printf \"username=%s\\npassword=%s\\n\" \"$DOOMPI_GIT_USERNAME\" \"$DOOMPI_GIT_TOKEN\"; }; f";
+/** Whether a value holds an ASCII control character; a newline in a credential field could add a line to git's credential protocol. */
+function hasControl(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+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) {
+	try {
+		return node_fs.default.realpathSync(workspaceRoot);
+	} catch {
+		return node_path.default.resolve(workspaceRoot);
+	}
+}
+function expandHome(keyPath, homeDir) {
+	return keyPath.startsWith("~/") ? node_path.default.join(homeDir, keyPath.slice(2)) : keyPath;
+}
+function parseConfig(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.method === "none") return { method: "none" };
+	if (value.method === "ssh") {
+		if (value.keyPath === void 0) return { method: "ssh" };
+		return typeof value.keyPath === "string" && value.keyPath !== "" ? {
+			method: "ssh",
+			keyPath: value.keyPath
+		} : void 0;
+	}
+	if (value.method === "https" && typeof value.host === "string" && typeof value.username === "string" && typeof value.token === "string" && value.token !== "") return {
+		method: "https",
+		host: value.host,
+		username: value.username,
+		token: value.token
+	};
+}
+/** What the browser may see. The token becomes a yes or no. */
+function publicView(config) {
+	if (config.method === "ssh") return config.keyPath === void 0 ? {
+		method: "ssh",
+		ssh: {}
+	} : {
+		method: "ssh",
+		ssh: { keyPath: config.keyPath }
+	};
+	if (config.method === "https") return {
+		method: "https",
+		https: {
+			host: config.host,
+			username: config.username,
+			hasToken: config.token !== ""
+		}
+	};
+	return { method: "none" };
+}
+/**
+* A browser save request, checked field by field. An absent HTTPS token keeps
+* 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) {
+	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") {
+		if (request.keyPath === void 0 || request.keyPath === "") return { method: "ssh" };
+		if (typeof request.keyPath !== "string" || hasControl(request.keyPath)) throw require_worktreeOperations.invalidRequest("The key path is not a plain path.", "Give the key as an absolute path or one under ~/.");
+		const keyPath = request.keyPath.trim();
+		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();
+		} catch {
+			isFile = false;
+		}
+		if (!isFile) throw require_worktreeOperations.invalidRequest(`No key file at ${keyPath}.`, "Check the path, or leave it blank to use ssh-agent.");
+		return {
+			method: "ssh",
+			keyPath
+		};
+	}
+	if (request.method === "https") {
+		const host = typeof request.host === "string" ? request.host.trim().toLowerCase() : "";
+		if (!HOST_PATTERN.test(host)) throw require_worktreeOperations.invalidRequest("The host is not a host name.", "Use a host like github.com, with an optional :port.");
+		const username = typeof request.username === "string" ? request.username.trim() : "";
+		if (username === "" || username.length > MAX_USERNAME || hasControl(username)) throw require_worktreeOperations.invalidRequest("The username is empty or not plain text.", "Enter the username the host knows you by.");
+		if (request.token !== void 0 && request.token !== "") {
+			if (typeof request.token !== "string" || request.token.length > MAX_TOKEN || hasControl(request.token)) throw require_worktreeOperations.invalidRequest("The token is not plain text.", "Paste the token again without line breaks.");
+			return {
+				method: "https",
+				host,
+				username,
+				token: request.token
+			};
+		}
+		if (current.method === "https" && current.host === host && current.token !== "") return {
+			method: "https",
+			host,
+			username,
+			token: current.token
+		};
+		throw require_worktreeOperations.invalidRequest(current.method === "https" ? "The host changed, so the saved token cannot follow it." : "A token is required.", "Enter the personal access token for this host.");
+	}
+	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) {
+	try {
+		if ((node_fs.default.statSync(target).mode & LOOSE_BITS) !== 0) node_fs.default.chmodSync(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 workspaces = {};
+		if (isRecord(raw) && raw.version === 1 && isRecord(raw.workspaces)) for (const [key, value] of Object.entries(raw.workspaces)) {
+			const config = parseConfig(value);
+			if (config !== void 0) workspaces[key] = config;
+		}
+		return {
+			version: 1,
+			workspaces
+		};
+	};
+	const read = (workspaceRoot) => readFile().workspaces[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);
+			const root = require_worktreeOperations.doomGitRoot(homeDir);
+			node_fs.default.mkdirSync(root, {
+				recursive: true,
+				mode: OWNER_ONLY_DIRECTORY
+			});
+			node_fs.default.chmodSync(root, OWNER_ONLY_DIRECTORY);
+			const workspaces = { ...current.workspaces };
+			if (next.method === "none") delete workspaces[key];
+			else workspaces[key] = next;
+			require_worktreeOperations.writeJsonAtomic(file, {
+				version: 1,
+				workspaces
+			});
+			node_fs.default.chmodSync(file, OWNER_ONLY_FILE);
+			return publicView(next);
+		}
+	};
+}
+/** The transport and host a remote URL names, or undefined for a local path or anything else. */
+function remoteTransport(url) {
+	const trimmed = url.trim();
+	if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(trimmed)) try {
+		const parsed = new URL(trimmed);
+		const kind = parsed.protocol === "https:" ? "https" : parsed.protocol === "http:" ? "http" : parsed.protocol === "ssh:" ? "ssh" : void 0;
+		return kind === void 0 ? void 0 : {
+			kind,
+			host: parsed.host.toLowerCase()
+		};
+	} catch {
+		return;
+	}
+	const scp = /^(?:[^@/]+@)?([^:/]+):(?!\/\/)/u.exec(trimmed);
+	if (scp !== null && scp[1] !== void 0 && scp[1].length > 1) return {
+		kind: "ssh",
+		host: scp[1].toLowerCase()
+	};
+}
+/** Quotes one word for the POSIX shell git runs GIT_SSH_COMMAND through. */
+function shellQuote(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+/**
+* The environment for one fetch or push against `remoteUrl`.
+*
+* Every call drops tracing (which can log credentials) and turns prompts off,
+* because no terminal is attached. Only when the workspace's method matches the
+* remote does anything secret go in, and then only into this child's env.
+*/
+function remoteEnv(config, remoteUrl, baseEnv, homeDir) {
+	const env = { ...baseEnv };
+	for (const key of Object.keys(env)) if (STRIPPED_ALWAYS.includes(key) || STRIPPED_PREFIXES.some((prefix) => key.startsWith(prefix))) delete env[key];
+	env.GIT_TERMINAL_PROMPT = "0";
+	env.GCM_INTERACTIVE = "never";
+	const transport = remoteTransport(remoteUrl);
+	const credentialed = () => {
+		for (const key of Object.keys(env)) if (STRIPPED_CREDENTIALED.includes(key) || CONFIG_ENTRY.test(key)) delete env[key];
+		env.GIT_ASKPASS = "true";
+	};
+	if (config.method === "https") {
+		if (transport?.kind !== "https" || transport.host !== config.host) return {
+			env,
+			credentialed: false,
+			mismatch: `This workspace's token is for https://${config.host}, and this remote is not.`
+		};
+		credentialed();
+		env.GIT_CONFIG_COUNT = "3";
+		env.GIT_CONFIG_KEY_0 = "credential.helper";
+		env.GIT_CONFIG_VALUE_0 = "";
+		env.GIT_CONFIG_KEY_1 = `credential.https://${config.host}.helper`;
+		env.GIT_CONFIG_VALUE_1 = ENV_CREDENTIAL_HELPER;
+		env.GIT_CONFIG_KEY_2 = "http.sslVerify";
+		env.GIT_CONFIG_VALUE_2 = "true";
+		env.GIT_ALLOW_PROTOCOL = "https";
+		env.DOOMPI_GIT_USERNAME = config.username;
+		env.DOOMPI_GIT_TOKEN = config.token;
+		return {
+			env,
+			credentialed: true
+		};
+	}
+	if (config.method === "ssh") {
+		if (transport?.kind !== "ssh") return {
+			env,
+			credentialed: false,
+			mismatch: "This workspace uses SSH, and this remote is not an SSH remote."
+		};
+		credentialed();
+		env.GIT_SSH_COMMAND = [
+			"ssh",
+			...config.keyPath === void 0 ? [] : [
+				"-i",
+				shellQuote(expandHome(config.keyPath, homeDir)),
+				"-o",
+				"IdentitiesOnly=yes"
+			],
+			"-o",
+			"BatchMode=yes",
+			"-o",
+			"ConnectTimeout=15"
+		].join(" ");
+		env.GIT_ALLOW_PROTOCOL = "ssh";
+		return {
+			env,
+			credentialed: true
+		};
+	}
+	return {
+		env,
+		credentialed: false
+	};
+}
+//#endregion
+//#region src/services/newSessionRequest/index.ts
+const MAX_NAME_LENGTH = 120;
+/** Trimmed text, undefined when absent or blank, false when not text at all. */
+function optionalText(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") return false;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/**
+* Validates a new-session dialog request for a worktree session. Every ref is
+* checked here, before it can reach git as a positional argument.
+*/
+function newSessionRequest(body) {
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return { error: "A request body is required." };
+	const record = body;
+	const branch = optionalText(record.branch);
+	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 };
+	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." };
+		return {
+			mode: "existing-branch",
+			branch,
+			...remote === void 0 ? {} : { remote },
+			...named
+		};
+	}
+	if (record.mode === "new-branch") {
+		const baseRef = optionalText(record.baseRef);
+		if (baseRef === false || baseRef !== void 0 && !require_worktreeOperations.validRefName(baseRef)) return { error: "That base branch is not valid." };
+		return {
+			mode: "new-branch",
+			branch,
+			...baseRef === void 0 ? {} : { baseRef },
+			...named
+		};
+	}
+	return { error: "The mode must be existing-branch or new-branch." };
+}
+//#endregion
+//#region src/extensions/(backend)/api/git/_lib/route.server.ts
+/**
+* The worktree surface the cockpit panel calls.
+*
+* Hub-scoped because worktrees are a property of a repository, not of one
+* session: the panel lists and creates them whether or not the session that
+* made them is focused, and a session-scoped API would disappear with it.
+*
+* The panel names a repository by the hub's opaque id and never by path.
+* `resolveRepository` turns that into an admitted root, so a browser cannot
+* point this at a directory the cockpit was never given.
+*/
+function badRequest(message) {
+	return Response.json({ error: message }, { status: 400 });
+}
+function failed(error) {
+	if (error instanceof require_worktreeOperations.DoomGitExpectedError) return Response.json({
+		error: error.message,
+		code: error.code
+	}, { 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_doompi_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
+			});
+		};
+		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)
+				};
+				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 });
+		};
+		/** 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();
+		/**
+		* 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.DoomGitExpectedError && 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 same request.
+		*/
+		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 result = await branchDiff.review(cwd, recordedBaseRef === void 0 ? {} : { recordedBaseRef });
+			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 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);
+				}
+			},
+			close() {}
+		};
+	}
+});
+//#endregion
+//#region src/services/gitFailure/index.ts
+const RULES = [
+	{
+		code: "host_key_changed",
+		phrases: ["remote host identification has changed"],
+		message: "The remote's SSH host key changed since this machine last saw it.",
+		recovery: "Check with the host that the change is expected, then update ~/.ssh/known_hosts from a terminal.",
+		retryable: false
+	},
+	{
+		code: "host_key_unknown",
+		phrases: [
+			"host key verification failed",
+			"no ed25519 host key is known",
+			"no rsa host key is known"
+		],
+		message: "This machine does not trust the remote's SSH host key yet.",
+		recovery: "Run `ssh -T git@<host>` once in a terminal and accept the key, then try again.",
+		retryable: false
+	},
+	{
+		code: "auth_failed",
+		phrases: [
+			"authentication failed",
+			"could not read username",
+			"could not read password",
+			"permission denied (publickey",
+			"returned error: 401",
+			"returned error: 403",
+			"terminal prompts disabled",
+			"load key",
+			"unprotected private key",
+			"invalid format"
+		],
+		message: "The remote refused the credentials.",
+		recovery: `Check this workspace's git remote auth. ${SETTINGS_HINT}`,
+		retryable: false
+	},
+	{
+		code: "repository_not_found",
+		phrases: ["repository not found", "does not appear to be a git repository"],
+		message: "The remote repository was not found, or these credentials cannot see it.",
+		recovery: `Check the remote URL and that the credentials have access. ${SETTINGS_HINT}`,
+		retryable: false
+	},
+	{
+		code: "remote_unreachable",
+		phrases: [
+			"could not resolve host",
+			"connection refused",
+			"connection timed out",
+			"operation timed out",
+			"unable to access",
+			"network is unreachable"
+		],
+		message: "The remote could not be reached.",
+		recovery: "Check the network and the remote URL, then try again.",
+		retryable: true
+	},
+	{
+		code: "push_lease_rejected",
+		phrases: ["(stale info)"],
+		message: "The remote branch moved since your last fetch, so the force push was refused.",
+		recovery: "Pull to see the new commits, then decide whether to push again.",
+		retryable: false
+	},
+	{
+		code: "push_needs_force",
+		phrases: ["(non-fast-forward)", "(fetch first)"],
+		message: "The remote branch has commits yours replaced, usually after a rebase.",
+		recovery: "Confirm a force push with lease, or pull first to keep the remote commits.",
+		retryable: false
+	},
+	{
+		code: "worktree_dirty",
+		phrases: [
+			"unstaged changes",
+			"uncommitted changes",
+			"would be overwritten",
+			"your index contains uncommitted changes"
+		],
+		message: "There are uncommitted changes in the way.",
+		recovery: "Commit or stash your changes first.",
+		retryable: false
+	}
+];
+function classifyGitFailure(operation, result, mismatch) {
+	if (result.timedOut) return new require_worktreeOperations.DoomGitExpectedError("git_timeout", `git ${operation} took too long and was stopped.`, true, "Check the network, then try again.");
+	const text = `${result.stderr}\n${result.stdout}`.toLowerCase();
+	const rule = RULES.find((candidate) => candidate.phrases.some((phrase) => text.includes(phrase)));
+	if (rule === void 0) return new require_worktreeOperations.DoomGitExpectedError("git_failed", `git ${operation} failed (exit ${String(result.code)}).`, false, "Run the same command in a terminal in this checkout to see what git says.");
+	const recovery = rule.code === "auth_failed" && mismatch !== void 0 ? `${mismatch} ${rule.recovery}` : rule.recovery;
+	return new require_worktreeOperations.DoomGitExpectedError(rule.code, rule.message, rule.retryable, recovery);
+}
+//#endregion
+//#region src/services/gitSync/index.ts
+/**
+* Manual pull, push and rebase for a session's checkout.
+*
+* DESIGN PATTERNS:
+* - The workspace's auth goes into the environment of the one fetch or push
+*   that needs it, built fresh per call. Rebase itself runs locally and never
+*   sees a credential.
+* - Fetch and rebase are separate commands, so a hung network can never leave a
+*   rebase half applied.
+* - A conflicted rebase is not an error. It is left paused for the reader to
+*   hand to the agent or abort, and git's own state reports it from then on.
+* - Pull and rebase refuse uncommitted tracked changes rather than stash them.
+*   Untracked files only block when git says they would be overwritten.
+* - Push never forces on its own. A rejection comes back as `push_needs_force`,
+*   and only a confirmed retry sends `--force-with-lease --force-if-includes`,
+*   which git refuses if the remote holds commits this branch never integrated.
+*/
+const DONE = { outcome: "done" };
+function expected(code, message, recovery) {
+	return new require_worktreeOperations.DoomGitExpectedError(code, message, false, recovery);
+}
+async function readLine(cwd, args) {
+	const result = await require_worktreeOperations.runGit(cwd, args, { timeout: require_worktreeOperations.READ_TIMEOUT_MS });
+	const out = result.stdout.trim();
+	return result.code === 0 && out !== "" ? out : void 0;
+}
+async function toplevel(cwd) {
+	const root = await readLine(cwd, ["rev-parse", "--show-toplevel"]);
+	if (root === void 0) throw expected("not_a_repository", "This session is not in a git checkout.", "Open the session in a git repository.");
+	return root;
+}
+async function rebasing(root) {
+	for (const name of ["rebase-merge", "rebase-apply"]) {
+		const gitPath = await readLine(root, [
+			"rev-parse",
+			"--git-path",
+			name
+		]);
+		if (gitPath !== void 0 && node_fs.default.existsSync(node_path.default.resolve(root, gitPath))) return true;
+	}
+	return false;
+}
+async function conflicts(root) {
+	return (await require_worktreeOperations.runGit(root, [
+		"diff",
+		"--name-only",
+		"--diff-filter=U",
+		"-z"
+	], { timeout: require_worktreeOperations.READ_TIMEOUT_MS })).stdout.split("\0").filter((file) => file !== "");
+}
+async function currentBranch(root) {
+	const branch = await readLine(root, [
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	]);
+	if (branch === void 0) throw expected("detached_head", "HEAD is detached, so there is no branch to sync.", "Check out a branch first.");
+	return branch;
+}
+async function guard(root, needsCleanTree) {
+	if (await rebasing(root)) throw expected("rebase_in_progress", "A rebase is paused in this checkout.", "Ask the agent to resolve it, or abort the rebase.");
+	const branch = await currentBranch(root);
+	if (needsCleanTree) {
+		if (await readLine(root, [
+			"status",
+			"--porcelain",
+			"--untracked-files=no"
+		]) !== void 0) throw expected("worktree_dirty", "There are uncommitted changes.", "Commit or stash your changes first.");
+	}
+	return branch;
+}
+function createGitSync(options) {
+	const baseEnv = options.baseEnv ?? process.env;
+	/** One credentialed network command against `remote`, classified on failure. */
+	const network = async (root, context, remote, operation, args, urlArgs = []) => {
+		const url = await readLine(root, [
+			"remote",
+			"get-url",
+			...urlArgs,
+			remote
+		]);
+		if (url === void 0) throw expected("no_remote", `There is no remote named ${remote}.`, "Add the remote in a terminal first.");
+		const prepared = remoteEnv(context.auth, url, baseEnv, options.homeDir);
+		const result = await require_worktreeOperations.runGit(root, args, {
+			timeout: require_worktreeOperations.NETWORK_TIMEOUT_MS,
+			env: prepared.env
+		});
+		if (result.code !== 0) throw classifyGitFailure(operation, result, prepared.mismatch);
+	};
+	/** Rebases onto `onto`; a stop on conflicts leaves the rebase paused and says so. */
+	const rebaseOnto = async (root, onto) => {
+		const result = await require_worktreeOperations.runGit(root, ["rebase", onto], {
+			timeout: require_worktreeOperations.REBASE_TIMEOUT_MS,
+			env: {
+				...baseEnv,
+				GIT_EDITOR: "true",
+				GIT_TERMINAL_PROMPT: "0"
+			}
+		});
+		if (result.code === 0) return DONE;
+		if (await rebasing(root)) return {
+			outcome: "paused",
+			conflicts: await conflicts(root)
+		};
+		throw classifyGitFailure("rebase", result);
+	};
+	/** The remote a ref like `origin/main` or `refs/remotes/origin/main` belongs to. */
+	const remoteOfRef = async (root, ref) => {
+		const full = await readLine(root, [
+			"rev-parse",
+			"--symbolic-full-name",
+			ref
+		]);
+		if (full === void 0 || !full.startsWith("refs/remotes/")) return void 0;
+		const rest = full.slice(13);
+		const cut = rest.indexOf("/");
+		return cut > 0 ? rest.slice(0, cut) : void 0;
+	};
+	return {
+		async pull(context) {
+			const root = await toplevel(context.cwd);
+			const branch = await guard(root, true);
+			const remote = await readLine(root, ["config", `branch.${branch}.remote`]);
+			const upstream = await readLine(root, [
+				"rev-parse",
+				"--abbrev-ref",
+				"--symbolic-full-name",
+				`${branch}@{upstream}`
+			]);
+			if (remote === void 0 || upstream === void 0) throw expected("no_upstream", `${branch} has no upstream to pull from.`, "Push once to set an upstream.");
+			if (remote !== ".") await network(root, context, remote, "fetch", [
+				"fetch",
+				"--prune",
+				remote
+			]);
+			return rebaseOnto(root, upstream);
+		},
+		async push(context, force) {
+			const root = await toplevel(context.cwd);
+			const branch = await guard(root, false);
+			const configuredRemote = await readLine(root, ["config", `branch.${branch}.remote`]);
+			const merge = await readLine(root, ["config", `branch.${branch}.merge`]);
+			let remote = configuredRemote;
+			let target = merge;
+			const args = ["push", "--porcelain"];
+			if (remote === void 0 || target === void 0 || remote === ".") {
+				const remotes = (await readLine(root, ["remote"]) ?? "").split("\n").filter((name) => name !== "");
+				remote = remotes.includes("origin") ? "origin" : remotes.length === 1 ? remotes[0] : void 0;
+				if (remote === void 0) throw expected("no_remote", "There is no remote to push to.", remotes.length === 0 ? "Add a remote in a terminal first." : "Push once from a terminal to choose the remote.");
+				target = `refs/heads/${branch}`;
+				args.push("--set-upstream");
+			}
+			if (force) args.push(`--force-with-lease=${target}`, "--force-if-includes");
+			args.push(remote, `HEAD:${target}`);
+			await network(root, context, remote, "push", args, ["--push"]);
+			return DONE;
+		},
+		async rebase(context) {
+			const root = await toplevel(context.cwd);
+			const base = await resolveBaseRef(root, await guard(root, true), context.recordedBaseRef);
+			if (base === void 0) throw expected("no_base", "No base branch to rebase onto.", "Fetch the remote, or create the worktree from a base.");
+			const remote = await remoteOfRef(root, base);
+			if (remote !== void 0) await network(root, context, remote, "fetch", [
+				"fetch",
+				"--prune",
+				remote
+			]);
+			return rebaseOnto(root, base);
+		},
+		async abortRebase(context) {
+			const root = await toplevel(context.cwd);
+			if (!await rebasing(root)) return DONE;
+			const result = await require_worktreeOperations.runGit(root, ["rebase", "--abort"], { timeout: require_worktreeOperations.REBASE_TIMEOUT_MS });
+			if (result.code !== 0) throw classifyGitFailure("rebase --abort", result);
+			return DONE;
+		}
+	};
+}
+//#endregion
+//#region src/types/gitReview.ts
+/**
+* The cockpit's view of what this session changed against its base: the counts
+* the '# diff' group shows, what the review tab lists and draws, and the manual
+* sync that sits beside them.
+*
+* DESIGN PATTERNS:
+* - Declarations only, shared by the hub and the page.
+* - Its own channel, apart from worktrees. Worktrees are repository
+*   management; the diff is this session's code change.
+* - A diff row carries one line number whose file follows from its marker: the
+*   new file's for context and additions, the old file's for removals. It is
+*   the same shape the shared DiffView draws.
+*
+* AVOID:
+* - Behaviour or node builtins. Browser code imports this file.
+*/
+/** The session channel carrying this checkout's changes and the sync around them. */
+const GIT_CHANGES_TYPE = "git_changes";
+//#endregion
+//#region src/extensions/(backend)/channel/_lib/git-changes.server.ts
+/**
+* The '# diff' data channel: this session's change against its base, and the
+* manual sync commands the review tab sends back through it.
+*
+* 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.
+* - 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.
+*
+* AVOID:
+* - Echoing git output. Failures go through classifyGitFailure, which matches
+*   stderr and drops it, because a remote URL in it can carry a token.
+*/
+function payloadOf$1(state) {
+	return {
+		...state.changes === void 0 ? {} : { changes: state.changes },
+		...state.pending === void 0 ? {} : { pending: state.pending },
+		...state.error === void 0 ? {} : { error: state.error },
+		...state.errorTarget === void 0 ? {} : { errorTarget: state.errorTarget }
+	};
+}
+/** A command the page sent, or undefined when the frame was not one. */
+function parseChangesCommand(payload) {
+	if (typeof payload !== "object" || payload === null) return void 0;
+	const value = payload;
+	if (value.action === "pull" || value.action === "rebase" || value.action === "abort-rebase") return { action: value.action };
+	if (value.action === "push") return value.force === true ? {
+		action: "push",
+		force: true
+	} : { action: "push" };
+}
+const PENDING = {
+	pull: "pulling…",
+	push: "pushing…",
+	rebase: "rebasing…",
+	"abort-rebase": "aborting the rebase…"
+};
+/** The error target a failure maps to: a rejected plain push asks for a confirmed lease force. */
+function errorTargetFor$1(command, error) {
+	if (command.action !== "push") return { action: command.action };
+	return error instanceof require_worktreeOperations.DoomGitExpectedError && error.code === "push_needs_force" && command.force !== true ? {
+		action: "push",
+		forceRequired: true
+	} : { action: "push" };
+}
+function failureText$1(error) {
+	if (error instanceof require_worktreeOperations.DoomGitExpectedError) return error.message.replace(/^\[[a-z_]+\] /u, "").replace("\nRecovery: ", " ");
+	return "The git command failed.";
+}
+function createGitChangesChannel(options = {}) {
+	let receiveCommand;
+	return {
+		frameType: GIT_CHANGES_TYPE,
+		start(host) {
+			const homeDir = options.homeDir ?? node_os.default.homedir();
+			const diff = options.diff ?? createBranchDiff();
+			const sync = options.sync ?? createGitSync({ homeDir });
+			const auth = options.auth ?? createGitAuthStore(homeDir);
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			const scopes = /* @__PURE__ */ new Map();
+			const inFlight = /* @__PURE__ */ new Set();
+			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) => {
+				try {
+					return require_worktreeOperations.createWorktreeRegistry(require_worktreeOperations.registryFile(scope.cwd, homeDir)).list().find((record) => record.sessionId === scope.sessionId)?.baseRef;
+				} catch {
+					return;
+				}
+			};
+			/** Republishes a session, skipping a frame that would say nothing new. */
+			const publish = (sessionId, next) => {
+				const previous = latest.get(sessionId);
+				latest.set(sessionId, next);
+				if (previous !== void 0 && JSON.stringify(payloadOf$1(previous)) === JSON.stringify(payloadOf$1(next))) return;
+				host.publish(sessionId, payloadOf$1(next));
+			};
+			const update = (sessionId, patch) => {
+				const previous = latest.get(sessionId) ?? {
+					changes: void 0,
+					pending: void 0,
+					error: void 0,
+					errorTarget: void 0
+				};
+				publish(sessionId, {
+					...previous,
+					...patch
+				});
+			};
+			/** Recounts one session; a request while one runs schedules exactly one more. */
+			const refresh = (sessionId) => {
+				const scope = scopes.get(sessionId);
+				if (scope === void 0) return;
+				if (inFlight.has(sessionId)) {
+					rerun.add(sessionId);
+					return;
+				}
+				inFlight.add(sessionId);
+				const base = recordedBaseRef(scope);
+				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"})`);
+				}).finally(() => {
+					inFlight.delete(sessionId);
+					if (rerun.delete(sessionId)) refresh(sessionId);
+				});
+			};
+			const run = (scope, command) => {
+				const workspaceRoot = scope.sessionContext?.workspaceRoot ?? scope.cwd;
+				const base = recordedBaseRef(scope);
+				const context = {
+					cwd: scope.cwd,
+					auth: auth.read(workspaceRoot),
+					...base === void 0 ? {} : { recordedBaseRef: base }
+				};
+				if (command.action === "pull") return sync.pull(context);
+				if (command.action === "push") return sync.push(context, command.force === true);
+				if (command.action === "rebase") return sync.rebase(context);
+				return sync.abortRebase(context);
+			};
+			const source = {
+				payloadFor(scope) {
+					const state = latest.get(scope.sessionId);
+					return state === void 0 ? void 0 : payloadOf$1(state);
+				},
+				sessionAdded(scope) {
+					scopes.set(scope.sessionId, scope);
+					refresh(scope.sessionId);
+					const unsubscribe = host.directEvents.subscribe(require_worktreeOperations.GIT_SESSION_CHANGED_EVENT, scope.sessionId, (payload) => {
+						if (require_worktreeOperations.isSessionChangedEvent(payload)) refresh(scope.sessionId);
+					});
+					subscriptions.set(scope.sessionId, unsubscribe);
+				},
+				sessionRemoved(sessionId) {
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					scopes.delete(sessionId);
+					latest.delete(sessionId);
+					rerun.delete(sessionId);
+					busy.delete(sessionId);
+				},
+				close() {
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					scopes.clear();
+					latest.clear();
+					rerun.clear();
+					busy.clear();
+				}
+			};
+			receiveCommand = (scope, payload) => {
+				const command = parseChangesCommand(payload);
+				if (command === void 0 || !scopes.has(scope.sessionId)) return;
+				if (busy.has(scope.sessionId)) return;
+				busy.add(scope.sessionId);
+				update(scope.sessionId, {
+					pending: PENDING[command.action],
+					error: void 0,
+					errorTarget: void 0
+				});
+				run(scope, command).then(() => update(scope.sessionId, { pending: void 0 })).catch((error) => {
+					host.onNotice(`git ${command.action} failed for ${scope.sessionId} (${error instanceof require_worktreeOperations.DoomGitExpectedError ? error.code : "unexpected"})`);
+					update(scope.sessionId, {
+						pending: void 0,
+						error: failureText$1(error),
+						errorTarget: errorTargetFor$1(command, error)
+					});
+				}).finally(() => {
+					busy.delete(scope.sessionId);
+					refresh(scope.sessionId);
+				});
+			};
+			return source;
+		},
+		receive(scope, payload) {
+			receiveCommand?.(scope, payload);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/git-changes.server.ts
+var git_changes_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineChannel)(createGitChangesChannel);
+//#endregion
+//#region src/types/webWorktrees.ts
+/**
+* The cockpit's view of this session's worktrees.
+*
+* DESIGN PATTERNS:
+* - Declarations only. The channel frame type is a constant so the hub and the
+*   page cannot drift apart on a string.
+* - A view is the subset of a record the dock needs, not the record. The
+*   registry may hold paths and provenance the page has no business rendering.
+*
+* AVOID:
+* - Adding behaviour here. This file is imported by browser code, so it must
+*   stay free of node builtins.
+*/
+/** The data channel carrying one session's worktrees to the page. */
+const GIT_WORKTREES_TYPE = "git_worktrees";
+//#endregion
+//#region src/extensions/(backend)/channel/_lib/git-worktrees.server.ts
+function payloadOf(state) {
+	return {
+		worktrees: state.worktrees,
+		...state.pending === void 0 ? {} : { pending: state.pending },
+		...state.error === void 0 ? {} : { error: state.error },
+		...state.errorTarget === void 0 ? {} : { errorTarget: state.errorTarget }
+	};
+}
+/** Worktrees visible to this session, using the hub's live session table for ownership. */
+function viewsFor(scope, deps) {
+	try {
+		return require_worktreeOperations.createWorktreeRegistry(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);
+			if (!owned && !unowned) return [];
+			return [{
+				id: record.id,
+				branch: record.branch,
+				path: record.path,
+				sessionId: record.status === "orphaned" ? null : record.sessionId,
+				orphaned: record.status === "orphaned",
+				unowned
+			}];
+		});
+	} catch {
+		return [];
+	}
+}
+function sameList(left, right) {
+	if (left.length !== right.length) return false;
+	return left.every((entry, index) => {
+		const other = right[index];
+		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" } : {
+		action: "close",
+		id: command.id
+	};
+}
+/** A command the page sent, or undefined when the frame was not one. */
+function parseCommand(payload) {
+	if (typeof payload !== "object" || payload === null) return void 0;
+	const value = payload;
+	if (value.action === "create") {
+		if (typeof value.branch !== "string" || value.branch.trim() === "") return void 0;
+		if (value.reservationId !== void 0 && (typeof value.reservationId !== "string" || !/^[A-Za-z0-9_-]+$/u.test(value.reservationId))) return void 0;
+		return {
+			action: "create",
+			branch: value.branch.trim(),
+			...typeof value.baseRef === "string" && value.baseRef.trim() !== "" ? { baseRef: value.baseRef.trim() } : {},
+			...typeof value.reservationId === "string" ? { reservationId: value.reservationId } : {}
+		};
+	}
+	if (value.action === "close") {
+		if (typeof value.id !== "string" || value.id === "") return void 0;
+		return {
+			action: "close",
+			id: value.id,
+			...value.force === true ? { force: true } : {}
+		};
+	}
+}
+/**
+* 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.
+*/
+function failureText(error) {
+	return error instanceof require_worktreeOperations.DoomGitExpectedError ? error.message : "The worktree operation failed.";
+}
+/** Starts one direct-event subscription per managed session. */
+function createWorktreesChannel(options = {}) {
+	let receiveCommand;
+	return {
+		frameType: GIT_WORKTREES_TYPE,
+		start(host) {
+			const sessionService = host.sessionService;
+			if (sessionService === void 0) throw new require_worktreeOperations.HubUnavailableError("The cockpit session service is unavailable. Start the cockpit and try again.");
+			const worktrees = options.operations ?? require_worktreeOperations.createWorktreeOperations({
+				git: require_worktreeOperations.createWorktreeGit(),
+				sessionService
+			});
+			/** Announces a successful mutation to this session's lifecycle subscribers. */
+			const publishLifecycle = (scope, repositoryRoot) => {
+				host.directEvents.publish(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, scope.sessionId, {
+					version: 1,
+					repositoryRoot
+				});
+			};
+			const unregisterWorktreeProvisioner = sessionService.registerReservedWorktreeProvisioner?.(async ({ reservationId, parentSessionId, signal }) => {
+				const parent = host.sessions().find((scope) => scope.sessionId === parentSessionId);
+				if (parent === void 0) throw new Error("The conversation parent session is unavailable.");
+				const branch = `doompi/conversation-${reservationId.slice(0, 12)}`;
+				const record = await worktrees.spawn({
+					cwd: parent.cwd,
+					sessionId: parent.sessionId
+				}, {
+					branch,
+					name: `conversation ${reservationId.slice(0, 8)}`,
+					reservationId
+				}, { signal });
+				const reservations = sessionService.reservations;
+				if (reservations === void 0) throw new Error("Conversation reservations are unavailable.");
+				const session = await reservations.complete(reservationId, parentSessionId);
+				publishLifecycle(parent, record.repositoryRoot);
+				return session;
+			});
+			const views = {
+				homeDir: options.homeDir,
+				sessionService
+			};
+			const latest = /* @__PURE__ */ new Map();
+			const subscriptions = /* @__PURE__ */ new Map();
+			const busy = /* @__PURE__ */ new Set();
+			const generations = /* @__PURE__ */ new Map();
+			const newGeneration = (sessionId) => {
+				const generation = Symbol(sessionId);
+				generations.set(sessionId, generation);
+				return generation;
+			};
+			/** Republishes a session, skipping a frame that would say nothing new. */
+			const publish = (scope, force) => {
+				const previous = latest.get(scope.sessionId);
+				const next = {
+					worktrees: viewsFor(scope, views),
+					pending: previous?.pending,
+					error: previous?.error,
+					errorTarget: previous?.errorTarget
+				};
+				if (!force && previous !== void 0 && sameList(previous.worktrees, next.worktrees) && previous.pending === next.pending && previous.error === next.error && previous.errorTarget === next.errorTarget) return;
+				latest.set(scope.sessionId, next);
+				host.publish(scope.sessionId, payloadOf(next));
+			};
+			const mark = (scope, pending, error, errorTarget) => {
+				const previous = latest.get(scope.sessionId);
+				latest.set(scope.sessionId, {
+					worktrees: previous?.worktrees ?? viewsFor(scope, views),
+					pending,
+					error,
+					errorTarget
+				});
+				publish(scope, true);
+			};
+			const run = async (scope, command, generation) => {
+				const context = {
+					cwd: scope.cwd,
+					sessionId: scope.sessionId
+				};
+				const markCurrent = (pending, error, errorTarget) => {
+					if (generations.get(scope.sessionId) !== generation) return;
+					mark(scope, pending, error, errorTarget);
+				};
+				if (command.action === "create") {
+					markCurrent(`creating ${command.branch}…`, void 0, void 0);
+					const record = await worktrees.spawn(context, {
+						branch: command.branch,
+						...command.baseRef === void 0 ? {} : { baseRef: command.baseRef },
+						...command.reservationId === void 0 ? {} : { reservationId: command.reservationId }
+					}, { onProgress: (label) => markCurrent(label, void 0, void 0) });
+					if (generations.get(scope.sessionId) !== generation) return;
+					publishLifecycle(scope, record.repositoryRoot);
+					return;
+				}
+				markCurrent(`closing ${command.id}…`, void 0, void 0);
+				const record = await worktrees.close(context, command.id, command.force ?? false);
+				if (generations.get(scope.sessionId) !== generation) return;
+				publishLifecycle(scope, record.repositoryRoot);
+			};
+			const source = {
+				payloadFor(scope) {
+					const state = latest.get(scope.sessionId);
+					return state === void 0 ? void 0 : payloadOf(state);
+				},
+				sessionAdded(scope) {
+					newGeneration(scope.sessionId);
+					publish(scope, false);
+					const unsubscribe = host.directEvents.subscribe(require_worktreeOperations.GIT_WORKTREE_LIFECYCLE_EVENT, scope.sessionId, (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);
+						} catch {
+							sameRepository = false;
+						}
+						if (sameRepository) publish(scope, false);
+					});
+					subscriptions.set(scope.sessionId, unsubscribe);
+				},
+				sessionRemoved(sessionId) {
+					newGeneration(sessionId);
+					subscriptions.get(sessionId)?.();
+					subscriptions.delete(sessionId);
+					latest.delete(sessionId);
+					busy.delete(sessionId);
+				},
+				close() {
+					unregisterWorktreeProvisioner?.();
+					for (const unsubscribe of subscriptions.values()) unsubscribe();
+					subscriptions.clear();
+					latest.clear();
+					busy.clear();
+					generations.clear();
+				}
+			};
+			receiveCommand = (scope, payload) => {
+				const command = parseCommand(payload);
+				if (command === void 0) return;
+				if (busy.has(scope.sessionId)) return;
+				const generation = generations.get(scope.sessionId);
+				if (generation === void 0) return;
+				busy.add(scope.sessionId);
+				run(scope, command, generation).then(() => {
+					if (generations.get(scope.sessionId) !== generation) return;
+					mark(scope, void 0, void 0, void 0);
+				}).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));
+				}).finally(() => {
+					if (generations.get(scope.sessionId) === generation) busy.delete(scope.sessionId);
+				});
+			};
+			return source;
+		},
+		receive(scope, payload) {
+			receiveCommand?.(scope, payload);
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/git-worktrees.server.ts
+var git_worktrees_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineChannel)(createWorktreesChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineHook)((context) => context.root.hooks[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineHook)((context) => context.root.hooks[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/doompiGit.server.ts
+var doompiGit_server_default$1 = (context) => context.root.resources[0];
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompiGit.server.ts
+var doompiGit_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineResource)(doompiGit_server_default$1);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/doompiGitReadme.server.ts
+var doompiGitReadme_server_default$1 = (context) => context.root.resources[2];
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompiGitReadme.server.ts
+var doompiGitReadme_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineResource)(doompiGitReadme_server_default$1);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/_lib/doompiUseGit.server.ts
+var doompiUseGit_server_default$1 = (context) => context.root.resources[1];
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompiUseGit.server.ts
+var doompiUseGit_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineResource)(doompiUseGit_server_default$1);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/runWorktree.server.ts
+var runWorktree_server_default = (0, _agimon_ai_doompi_core_extensionFile.defineServerTool)((context) => context.root.tool);
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = (0, _agimon_ai_doompi_core_serverFacet.defineServerPlugin)({
+	name: "@agimon-ai/doompi-git",
+	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())];
+		}
+	}),
+	workspace: (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())];
+		}
+	}),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...(0, _agimon_ai_doompi_core_extensionFile.composeRootHooks)(scopeSession),
+			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())];
+			},
+			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(doompiGit_server_default, contextSession),
+					at(doompiGitReadme_server_default, contextSession),
+					at(doompiUseGit_server_default, contextSession)
+				];
+			},
+			get tools() {
+				return [via({ name: "run_worktree" }, at(runWorktree_server_default, contextSession))];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+exports.default = facet;
+exports.facet = facet;
+
+//# sourceMappingURL=server.cjs.map