@agimon-ai/doompi-git 0.0.1-alpha.3 → 0.0.1-alpha.31

package/dist/extensions/server.cjs

@@ -0,0 +1,588 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_worktreeOperations = require("../worktreeOperations-FJDk44Zt.cjs");
+const require_runWorktree = require("../runWorktree-D0bsyYc0.cjs");
+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)
+	});
+	return {
+		value: {
+			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")
+			}],
+			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))
+					});
+				}
+			}
+		},
+		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/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/_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/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;
+		};
+		return {
+			async fetch(request) {
+				const url = new URL(request.url);
+				try {
+					const answered = await newSession(request, url);
+					if (answered !== void 0) return answered;
+				} catch (error) {
+					context.onNotice(`new-session 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/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)/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_worktrees" }, git_worktrees_server_default())];
+		}
+	}),
+	workspace: (context) => ({
+		get api() {
+			return [at(route_server_default, context)];
+		},
+		get channels() {
+			return [() => 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_worktrees" }, git_worktrees_server_default())];
+			},
+			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