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

package/dist/extensions/web.mjs

@@ -0,0 +1,911 @@
+import { defineActivityGroup, defineChannelFile, defineFill, defineGlobalStore, defineSessionStore, defineToolRenderer, defineWebLifecycle, defineWebPlugin, workspaceApiPath } from "@agimon-ai/doompi-core/web";
+import { Button, Dialog, DialogBody, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, Dot, DropdownMenuItem, EmptyState, Input, MessageItem, MessageItemBody, MessageItemHeader, OptionRow, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Spinner, StatusBadge, toolTone } from "@agimon-ai/doompi-web-components";
+import { createElement, useEffect, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useStore } from "@tanstack/react-store";
+//#region src/constants/git.ts
+/** Workspace-mounted routes behind the new-session dialog. */
+const GIT_BRANCHES_PATH = "/branches";
+const GIT_SESSIONS_PATH = "/sessions";
+//#endregion
+//#region src/extensions/workspaces/(frontend)/_lib/newSessionForm.ts
+const MAX_LISTED = 200;
+/** Local branches first, then remote-only ones, filtered by a case-insensitive substring. */
+function branchOptions(branches, query) {
+	const needle = query.trim().toLowerCase();
+	const matches = (text) => needle === "" || text.toLowerCase().includes(needle);
+	const local = branches.local.filter((branch) => matches(branch.name)).map((branch) => ({
+		key: `local:${branch.name}`,
+		name: branch.name,
+		current: branch.name === branches.current,
+		...branch.checkedOutAt === void 0 ? {} : { busyAt: branch.checkedOutAt }
+	}));
+	const remote = branches.remote.filter((branch) => matches(`${branch.remote}/${branch.name}`)).map((branch) => ({
+		key: `remote:${branch.remote}/${branch.name}`,
+		name: branch.name,
+		remote: branch.remote,
+		current: false
+	}));
+	return [...local, ...remote].slice(0, MAX_LISTED);
+}
+/** Every base a new branch can start from: the default first, then remote-tracking names, then local branches. */
+function baseOptions(branches) {
+	return [.../* @__PURE__ */ new Set([
+		...branches.defaultBase === void 0 ? [] : [branches.defaultBase],
+		...branches.remote.map((branch) => `${branch.remote}/${branch.name}`),
+		...branches.local.map((branch) => branch.name)
+	])];
+}
+/** Why the form cannot be submitted yet, or undefined when it can. */
+function formProblem(state) {
+	if (state.mode === "existing") {
+		if (state.selected === void 0) return "Pick a branch.";
+		if (state.selected.busyAt !== void 0) return `That branch is checked out at ${state.selected.busyAt}.`;
+	}
+	if (state.mode === "new" && state.newBranch.trim() === "") return "Name the new branch.";
+}
+/** The worktree create request for the form, or undefined in plain mode. */
+function createRequest(state) {
+	const name = state.name.trim();
+	const named = name === "" ? {} : { name };
+	if (state.mode === "existing" && state.selected !== void 0) return {
+		mode: "existing-branch",
+		branch: state.selected.name,
+		...state.selected.remote === void 0 ? {} : { remote: state.selected.remote },
+		...named
+	};
+	if (state.mode === "new") {
+		const baseRef = state.baseRef.trim();
+		return {
+			mode: "new-branch",
+			branch: state.newBranch.trim(),
+			...baseRef === "" ? {} : { baseRef },
+			...named
+		};
+	}
+}
+//#endregion
+//#region src/extensions/workspaces/(frontend)/fill/_components/GitNewSessionDialog.tsx
+const MODES = [
+	{
+		mode: "existing",
+		label: "existing branch"
+	},
+	{
+		mode: "new",
+		label: "new branch"
+	},
+	{
+		mode: "plain",
+		label: "no branch"
+	}
+];
+function errorOf(body, status) {
+	return typeof body === "object" && body !== null && typeof body.error === "string" ? body.error : `The cockpit answered ${String(status)}.`;
+}
+/**
+* The new-session dialog when git is installed: a worktree on an existing or a
+* new branch, or a plain session in the workspace root. A worktree session
+* starts at the top level of the rail, with no parent.
+*/
+function GitNewSessionDialog({ newSession }) {
+	const [branches, setBranches] = useState(null);
+	const [loadError, setLoadError] = useState("");
+	const [form, setForm] = useState({
+		mode: "existing",
+		newBranch: "",
+		baseRef: "",
+		name: ""
+	});
+	const [query, setQuery] = useState("");
+	const [error, setError] = useState("");
+	const [busy, setBusy] = useState(false);
+	const workspaceId = newSession?.workspaceId;
+	const request = newSession?.requestWithStepUp;
+	useEffect(() => {
+		if (workspaceId === void 0 || request === void 0) return;
+		let stale = false;
+		const url = `${workspaceApiPath(workspaceId)}/plugins/git${GIT_BRANCHES_PATH}`;
+		request(url).then(async (response) => {
+			const body = await response.json().catch(() => void 0);
+			if (stale) return;
+			if (!response.ok) {
+				setLoadError(errorOf(body, response.status));
+				return;
+			}
+			const loaded = body;
+			setBranches(loaded);
+			setForm((current) => ({
+				...current,
+				baseRef: loaded.defaultBase ?? ""
+			}));
+		}).catch(() => {
+			if (!stale) setLoadError("The branches could not be loaded.");
+		});
+		return () => {
+			stale = true;
+		};
+	}, [workspaceId, request]);
+	if (newSession === void 0) return null;
+	const gitReady = branches?.repository === true && loadError === "";
+	const mode = gitReady || branches === null ? form.mode : "plain";
+	const state = {
+		...form,
+		mode
+	};
+	const problem = formProblem(state);
+	const options = branches === null ? [] : branchOptions(branches, query);
+	const bases = branches === null ? [] : baseOptions(branches);
+	const update = (patch) => setForm((current) => ({
+		...current,
+		...patch
+	}));
+	const submit = async () => {
+		if (busy || problem !== void 0) return;
+		setBusy(true);
+		setError("");
+		const body = createRequest(state);
+		let failure;
+		if (body === void 0) failure = await newSession.createPlain(state.name);
+		else try {
+			const response = await newSession.requestWithStepUp(`${workspaceApiPath(newSession.workspaceId)}/plugins/git${GIT_SESSIONS_PATH}`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(body)
+			});
+			const answer = await response.json().catch(() => void 0);
+			failure = response.ok ? await newSession.openCreated(answer.sessionId) : errorOf(answer, response.status);
+		} catch {
+			failure = "The cockpit is unreachable.";
+		}
+		if (failure === void 0) return;
+		setError(failure);
+		setBusy(false);
+	};
+	return /* @__PURE__ */ jsx(Dialog, {
+		open: true,
+		onOpenChange: (next) => !next && !busy && newSession.close(),
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			width: "md",
+			"data-testid": "new-session-dialog",
+			"aria-describedby": void 0,
+			children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: "new session" }) }), /* @__PURE__ */ jsxs(DialogBody, { children: [
+				/* @__PURE__ */ jsx("p", {
+					className: "truncate text-xs text-doom-faint",
+					title: newSession.workspaceRoot,
+					children: newSession.workspaceRoot
+				}),
+				gitReady ? /* @__PURE__ */ jsx("div", {
+					role: "radiogroup",
+					"aria-label": "session kind",
+					className: "flex gap-1",
+					children: MODES.map((entry) => /* @__PURE__ */ jsx(Button, {
+						role: "radio",
+						"aria-checked": mode === entry.mode,
+						variant: mode === entry.mode ? "outline" : "ghost",
+						size: "sm",
+						"data-testid": `git-new-session-mode-${entry.mode}`,
+						disabled: busy,
+						className: mode === entry.mode ? "border-doom-blue/60 text-doom-hi" : void 0,
+						onClick: () => update({ mode: entry.mode }),
+						children: entry.label
+					}, entry.mode))
+				}) : branches === null && loadError === "" ? /* @__PURE__ */ jsx("p", {
+					className: "text-xs text-doom-faint",
+					children: "reading branches…"
+				}) : /* @__PURE__ */ jsx("p", {
+					"data-testid": "git-new-session-plain-note",
+					className: "text-xs text-doom-faint",
+					children: loadError || "This workspace is not a git checkout, so the session starts in its folder."
+				}),
+				mode === "existing" && gitReady ? /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-1",
+					children: [/* @__PURE__ */ jsx(Input, {
+						"data-testid": "git-new-session-branch-search",
+						"aria-label": "find a branch",
+						value: query,
+						autoFocus: true,
+						disabled: busy,
+						onChange: (event) => setQuery(event.target.value),
+						placeholder: "find a branch"
+					}), /* @__PURE__ */ jsxs("div", {
+						role: "listbox",
+						"aria-label": "branches",
+						className: "max-h-48 overflow-y-auto rounded border border-doom-border bg-doom-deep p-1",
+						children: [options.length === 0 ? /* @__PURE__ */ jsx("p", {
+							className: "px-2 py-1 text-2xs text-doom-faint",
+							children: "no matching branches"
+						}) : null, options.map((option) => /* @__PURE__ */ jsxs(OptionRow, {
+							density: "compact",
+							active: form.selected?.key === option.key,
+							disabled: option.busyAt !== void 0 || busy,
+							"data-testid": "git-new-session-branch-option",
+							"data-branch": option.name,
+							"data-remote": option.remote,
+							onClick: () => update({ selected: option }),
+							className: `w-full px-2.5 py-1 text-sm ${option.busyAt !== void 0 ? "opacity-50" : ""}`,
+							children: [/* @__PURE__ */ jsx("span", {
+								className: "min-w-0 flex-1 truncate",
+								children: option.remote === void 0 ? option.name : `${option.remote}/${option.name}`
+							}), /* @__PURE__ */ jsx("span", {
+								className: "shrink-0 text-2xs text-doom-faint",
+								children: option.current && option.busyAt !== void 0 ? "current · checked out" : option.current ? "current" : option.busyAt !== void 0 ? "checked out" : option.remote !== void 0 ? "remote" : ""
+							})]
+						}, option.key))]
+					})]
+				}) : null,
+				mode === "new" && gitReady ? /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col gap-2",
+					children: [/* @__PURE__ */ jsxs("label", {
+						htmlFor: "git-new-session-new-branch",
+						className: "flex flex-col gap-1",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "text-xs text-doom-faint",
+							children: "new branch"
+						}), /* @__PURE__ */ jsx(Input, {
+							id: "git-new-session-new-branch",
+							"data-testid": "git-new-session-new-branch",
+							value: form.newBranch,
+							autoFocus: true,
+							disabled: busy,
+							onChange: (event) => update({ newBranch: event.target.value }),
+							placeholder: "feature/my-change"
+						})]
+					}), /* @__PURE__ */ jsxs("span", {
+						className: "flex flex-col gap-1",
+						children: [/* @__PURE__ */ jsx("span", {
+							className: "text-xs text-doom-faint",
+							children: "from"
+						}), /* @__PURE__ */ jsxs(Select, {
+							value: form.baseRef,
+							onValueChange: (baseRef) => update({ baseRef }),
+							disabled: busy,
+							children: [/* @__PURE__ */ jsx(SelectTrigger, {
+								"data-testid": "git-new-session-base",
+								"aria-label": "base branch",
+								children: /* @__PURE__ */ jsx(SelectValue, { placeholder: "base branch" })
+							}), /* @__PURE__ */ jsx(SelectContent, { children: bases.map((base) => /* @__PURE__ */ jsx(SelectItem, {
+								value: base,
+								children: base === branches?.current ? `${base} (current)` : base
+							}, base)) })]
+						})]
+					})]
+				}) : null,
+				/* @__PURE__ */ jsxs("label", {
+					htmlFor: "new-session-name",
+					className: "flex flex-col gap-1",
+					children: [/* @__PURE__ */ jsxs("span", {
+						className: "text-xs text-doom-faint",
+						children: [
+							"name",
+							" ",
+							/* @__PURE__ */ jsxs("span", {
+								className: "text-doom-faint",
+								children: [
+									"(optional",
+									mode === "plain" ? "" : "; defaults to the branch",
+									")"
+								]
+							})
+						]
+					}), /* @__PURE__ */ jsx(Input, {
+						id: "new-session-name",
+						"data-testid": "new-session-name",
+						value: form.name,
+						autoFocus: mode === "plain",
+						disabled: busy,
+						onChange: (event) => update({ name: event.target.value }),
+						onKeyDown: (event) => {
+							if (event.key === "Enter") submit();
+						},
+						placeholder: "session name"
+					})]
+				}),
+				error ? /* @__PURE__ */ jsx("pre", {
+					"data-testid": "new-session-error",
+					className: "max-h-28 overflow-y-auto rounded border border-doom-edge-red bg-doom-tint-red/40 px-2.5 py-2 text-xs whitespace-pre-wrap text-doom-red",
+					children: error
+				}) : null,
+				/* @__PURE__ */ jsxs(DialogFooter, { children: [/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					"data-testid": "new-session-cancel",
+					disabled: busy,
+					onClick: () => newSession.close(),
+					children: "cancel"
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "primary",
+					"data-testid": "new-session-create",
+					title: problem,
+					disabled: busy || problem !== void 0,
+					onClick: () => void submit(),
+					children: busy ? mode === "plain" ? "creating…" : "creating worktree…" : "create"
+				})] })
+			] })]
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/(frontend)/fill/GitNewSession.new-session.web.tsx
+var GitNewSession_new_session_web_default = defineFill({ component: GitNewSessionDialog });
+//#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/workspaces/sessions/(frontend)/_lib/worktreesActivityStore.ts
+/**
+* The dock's view of this session's worktrees, and the commands it sends.
+*
+* DESIGN PATTERNS:
+* - Session-scoped store fed by one hub channel. The hub is authoritative; the
+*   page never reads a registry and never guesses.
+* - Actions are channel frames, not prompts. The hub half owns the tool's
+*   operations, so the panel names the work and the hub performs it; a
+*   worktree made from the dock is the same object the tool makes, without
+*   spending a turn of the conversation to ask for it.
+* - The sender lives in a store rather than a module variable, because a web
+*   plugin keeps no mutable module state and the page may reconnect.
+*
+* AVOID:
+* - Calling the hub package API from here. A dock slot gets no sealed request
+*   transport, and raw fetch breaks the remote cockpit.
+* - `sendSessionFrame` for a command. It envelopes the frame as a session
+*   command bound for the agent, which never reaches a channel's `receive`.
+*/
+const worktreeActivity = defineSessionStore({
+	worktrees: [],
+	pending: void 0,
+	error: void 0,
+	errorTarget: void 0
+});
+/** Captures the clicked card, so a focus change cannot retarget an open dialog. */
+const worktreeCreateDialog = defineGlobalStore(null);
+/**
+* The page's hub socket sender, held for as long as the plugin runs.
+*
+* Undefined before `startWorktreeRuntime` and after it disposes; a command
+* sent in that window is dropped rather than queued, because a queue would
+* replay a worktree create against a socket that has since changed sessions.
+*/
+const worktreeSender = defineGlobalStore(void 0);
+/** Binds the page's hub socket. The plugin host calls this once per page. */
+function startWorktreeRuntime(runtime) {
+	const send = (frame) => {
+		runtime.sendHubFrame(frame);
+	};
+	worktreeSender.update(() => send);
+	return () => {
+		worktreeSender.update((current) => current === send ? void 0 : current);
+		worktreeCreateDialog.update(() => null);
+	};
+}
+/**
+* Whether this session has worktree work in flight.
+*
+* A standing worktree is state, not work: it sits there until someone closes
+* it, so counting it would leave the session reading as busy forever, with a
+* "background work is still running" notice under a conversation where
+* nothing is running. Only a create or close actually in progress counts.
+*
+* The group stays visible either way. Declaring an active source at all is
+* what keeps it in the dock; this answers how it is drawn, not whether it is
+* there.
+*/
+const worktreeActivitySource = {
+	subscribe(listener) {
+		const subscription = worktreeActivity.store.subscribe(listener);
+		return () => subscription.unsubscribe();
+	},
+	isActive(sessionId) {
+		return worktreeActivity.select(worktreeActivity.store.state, sessionId).pending !== void 0;
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalText(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function optionalErrorTarget(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.action === "create") return { action: "create" };
+	if (value.action === "close" && typeof value.id === "string" && value.id !== "") return {
+		action: "close",
+		id: value.id
+	};
+}
+/** The plugin's session data channel: 'git_worktrees' payloads into the store. */
+const worktreesChannel = worktreeActivity.channel({
+	channel: GIT_WORKTREES_TYPE,
+	parse(input) {
+		if (!isRecord(input) || !Array.isArray(input.worktrees)) return null;
+		return {
+			worktrees: input.worktrees.filter(isRecord),
+			pending: optionalText(input.pending),
+			error: optionalText(input.error),
+			errorTarget: optionalErrorTarget(input.errorTarget)
+		};
+	},
+	reduce(_current, next) {
+		return next;
+	}
+});
+/** Sends one command to the session's worktrees channel. */
+function command(sessionId, payload) {
+	worktreeSender.store.state?.({
+		type: GIT_WORKTREES_TYPE,
+		sessionId,
+		payload
+	});
+}
+/** Asks the hub for a worktree. The hub answers on the same channel. */
+function requestWorktreeCreate(sessionId, branch, baseRef, reservationId) {
+	const trimmedBase = baseRef.trim();
+	command(sessionId, {
+		action: "create",
+		branch: branch.trim(),
+		...trimmedBase === "" ? {} : { baseRef: trimmedBase },
+		...reservationId === void 0 ? {} : { reservationId }
+	});
+}
+/** Asks the hub to close one worktree. Refusal on a dirty tree stays the hub's call. */
+function requestWorktreeClose(sessionId, id) {
+	command(sessionId, {
+		action: "close",
+		id
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/WorktreesPanel.tsx
+/**
+* The '# git' group's tab: this session's worktrees, and the form that makes one.
+*
+* DESIGN PATTERNS:
+* - Lives in the activity dock, opened by the group's name. A worktree is work
+*   in progress belonging to the session that started it, so it sits beside
+*   agents, runners and workflows rather than in a settings screen.
+* - Header, form, then cards, the same rhythm the runners and workflows panels
+*   use. A worktree row is a card because it carries three facts and two
+*   actions, which a single line cannot hold without becoming a puzzle.
+* - Local form state is never reset by a data refresh. Direct lifecycle events
+*   update the list without discarding a half-typed branch name.
+* - Acts through the plugin's own hub channel, so a worktree made here and one
+*   made by the tool take exactly the same path.
+* - Creating waits on the cockpit starting a session, so the hub reports each
+*   phase on that channel and the header shows it turning. A button that looks
+*   idle for two minutes reads as broken.
+*
+* AVOID:
+* - Deriving form state from refreshed store data instead of the user's input.
+* - Colour classes outside the token set. `doom-error`, `doom-line` and
+*   `doom-bright` are not tokens: they compile to nothing and the row silently
+*   loses its border.
+*/
+const WORKTREES_TAB_ID = "git-worktrees";
+function worktreesTab() {
+	return {
+		id: WORKTREES_TAB_ID,
+		label: "worktrees",
+		panel: WorktreesPanel
+	};
+}
+function WorktreesPanel({ sessionId, sessionReservationId }) {
+	const session = useStore(worktreeActivity.store, (state) => worktreeActivity.select(state, sessionId));
+	const [branch, setBranch] = useState("");
+	const [baseRef, setBaseRef] = useState("");
+	const busy = session.pending !== void 0;
+	const canCreate = sessionId !== null && branch.trim() !== "" && !busy;
+	const createError = session.errorTarget?.action === "create" ? session.error : void 0;
+	const closeErrorId = session.errorTarget?.action === "close" ? session.errorTarget.id : void 0;
+	const panelError = session.error !== void 0 && (session.errorTarget === void 0 || closeErrorId !== void 0 && !session.worktrees.some((worktree) => worktree.id === closeErrorId));
+	const create = () => {
+		if (sessionId === null || !canCreate) return;
+		requestWorktreeCreate(sessionId, branch, baseRef, sessionReservationId);
+		if (sessionReservationId === void 0) {
+			setBranch("");
+			setBaseRef("");
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "git-worktrees-panel",
+		className: "flex min-h-0 flex-1 flex-col overflow-auto",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-h-11 shrink-0 items-center gap-2.5 border-b border-doom-border-soft px-3 sm:px-[26px]",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "text-sm font-bold text-doom-hi",
+						children: "worktrees"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						"data-testid": "git-worktrees-count",
+						className: "text-xs text-doom-faint",
+						children: session.worktrees.length === 0 ? "none yet" : `${String(session.worktrees.length)} open`
+					}),
+					/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }),
+					session.pending === void 0 ? null : /* @__PURE__ */ jsxs("span", {
+						"data-testid": "git-worktree-pending",
+						className: "flex min-w-0 items-center gap-1.5",
+						children: [/* @__PURE__ */ jsx(Spinner, {
+							className: "h-3 w-3 shrink-0 text-doom-faint",
+							label: session.pending
+						}), /* @__PURE__ */ jsx("span", {
+							className: "min-w-0 truncate text-xs text-doom-dim",
+							children: session.pending
+						})]
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex shrink-0 flex-col gap-1.5 border-b border-doom-border-soft px-3 py-2.5 sm:px-[26px]",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [
+						/* @__PURE__ */ jsx(Input, {
+							"data-testid": "git-worktree-branch",
+							"aria-label": "Branch",
+							size: "sm",
+							className: "min-w-0 flex-1",
+							placeholder: "wt/fix-auth",
+							value: branch,
+							onChange: (event) => setBranch(event.target.value),
+							onKeyDown: (event) => {
+								if (event.key === "Enter") create();
+							}
+						}),
+						/* @__PURE__ */ jsx(Input, {
+							"data-testid": "git-worktree-base",
+							"aria-label": "Base ref",
+							size: "sm",
+							placeholder: "base (current)",
+							value: baseRef,
+							onChange: (event) => setBaseRef(event.target.value),
+							className: "w-32 shrink-0"
+						}),
+						/* @__PURE__ */ jsx(Button, {
+							"data-testid": "git-worktree-create",
+							size: "sm",
+							disabled: !canCreate,
+							onClick: create,
+							children: "Create"
+						})
+					]
+				}), createError === void 0 ? /* @__PURE__ */ jsx("p", {
+					className: "text-2xs text-doom-faint",
+					children: "Creates the worktree outside the repository and starts a session nested under this one."
+				}) : /* @__PURE__ */ jsx("p", {
+					role: "alert",
+					"data-testid": "git-worktree-error",
+					className: "text-2xs text-doom-red",
+					children: createError
+				})]
+			}),
+			panelError ? /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				"data-testid": "git-worktree-error",
+				className: "px-3 pt-2 text-2xs text-doom-red sm:px-[26px]",
+				children: session.error
+			}) : null,
+			session.worktrees.length === 0 ? /* @__PURE__ */ jsx(EmptyState, {
+				"data-testid": "git-worktrees-empty",
+				className: "px-4 py-8",
+				title: "no worktrees yet",
+				description: "a worktree is its own checkout on its own branch, with its own session nested under this one."
+			}) : /* @__PURE__ */ jsx("ul", {
+				"data-testid": "git-worktrees-list",
+				className: "flex flex-col gap-2.5 px-3 py-3 sm:px-[26px]",
+				children: session.worktrees.map((worktree) => /* @__PURE__ */ jsx(WorktreeCard, {
+					worktree,
+					sessionId,
+					busy,
+					error: closeErrorId === worktree.id ? session.error : void 0
+				}, worktree.id))
+			})
+		]
+	});
+}
+/** One worktree: what it is, where it is, and the one thing you can do to it. */
+function WorktreeCard({ worktree, sessionId, busy, error }) {
+	return /* @__PURE__ */ jsxs("li", {
+		"data-testid": `git-worktree-${worktree.id}`,
+		className: "flex min-w-0 flex-col gap-1.5 rounded-md border border-doom-border-soft bg-doom-panel p-2.5",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex min-w-0 items-center gap-1.5",
+				children: [
+					/* @__PURE__ */ jsx(Dot, { tone: worktree.orphaned ? "red" : worktree.sessionId === null ? "muted" : "blue" }),
+					/* @__PURE__ */ jsx("span", {
+						className: "min-w-0 flex-1 truncate text-sm font-bold text-doom-hi",
+						children: worktree.branch
+					}),
+					worktree.orphaned ? /* @__PURE__ */ jsx(StatusBadge, {
+						tone: "error",
+						size: "xs",
+						children: "orphaned"
+					}) : null,
+					worktree.unowned ? /* @__PURE__ */ jsx(StatusBadge, {
+						tone: "info",
+						size: "xs",
+						children: "unowned"
+					}) : null
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate text-2xs text-doom-faint",
+				children: worktree.path
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-1.5 pt-0.5",
+				children: [/* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1" }), sessionId === null ? null : /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					size: "xs",
+					disabled: busy,
+					"data-testid": `git-worktree-close-${worktree.id}`,
+					className: "px-2 text-2xs font-bold",
+					onClick: () => requestWorktreeClose(sessionId, worktree.id),
+					children: "close"
+				})]
+			}),
+			error === void 0 ? null : /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				"data-testid": "git-worktree-error",
+				className: "text-2xs text-doom-red",
+				children: error
+			})
+		]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/git.web.ts
+var git_web_default = defineActivityGroup({
+	keys: "g w",
+	activeSource: worktreeActivitySource,
+	marksBackgroundWork: false,
+	transientTab: worktreesTab,
+	order: 30
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/gitWorktrees.web.ts
+var gitWorktrees_web_default = defineChannelFile(worktreesChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorktreeCreateDialog.tsx
+function WorktreeSessionMenu({ sessionId, sessionReservationId }) {
+	return /* @__PURE__ */ jsx(DropdownMenuItem, {
+		disabled: sessionId === null,
+		"data-testid": `session-worktree-${sessionReservationId ?? sessionId}`,
+		onSelect: () => {
+			if (sessionId !== null) worktreeCreateDialog.update(() => ({
+				sessionId,
+				...sessionReservationId === void 0 ? {} : { reservationId: sessionReservationId }
+			}));
+		},
+		children: "create worktree session…"
+	});
+}
+function WorktreeCreateOverlay(props) {
+	const target = useStore(worktreeCreateDialog.store);
+	const { holdSessionChannels } = props;
+	useEffect(() => {
+		if (target === null) return;
+		return holdSessionChannels?.(target.sessionId, (frame) => {
+			if (frame.type !== worktreesChannel.channel) return;
+			const payload = worktreesChannel.parse(frame.payload);
+			if (payload !== null) worktreesChannel.apply(target.sessionId, payload);
+		});
+	}, [target, holdSessionChannels]);
+	if (target === null) return null;
+	return /* @__PURE__ */ jsx(Dialog, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) worktreeCreateDialog.update(() => null);
+		},
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			width: "lg",
+			"data-testid": "session-worktree-dialog",
+			children: [/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: "create worktree session" }) }), /* @__PURE__ */ jsxs(DialogBody, { children: [/* @__PURE__ */ jsx(DialogDescription, { children: "Creates a separate checkout and a new session. Existing sessions stay in their current directories." }), /* @__PURE__ */ createElement(WorktreesPanel, {
+				...props,
+				key: `${target.sessionId}:${target.reservationId ?? ""}`,
+				sessionId: target.sessionId,
+				sessionReservationId: target.reservationId
+			})] })]
+		})
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Worktree.session-menu.web.tsx
+var Worktree_session_menu_web_default = defineFill({ component: WorktreeSessionMenu });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/WorktreeCreate.overlay.web.tsx
+var WorktreeCreate_overlay_web_default = defineFill({ component: WorktreeCreateOverlay });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorktreesActivitySection.tsx
+/**
+* The '# git' group's body in the activity dock.
+*
+* DESIGN PATTERNS:
+* - One line per worktree, the same rule the runners rail follows: enough to
+*   notice it, not enough to work with it. The group's own name opens the tab
+*   that has room.
+* - Idle still shows the launcher. A repository with no worktrees is the state
+*   where someone most wants to make one.
+*
+* AVOID:
+* - Doing work here. This section reports and launches; the panel and the tool
+*   own everything else.
+*/
+function WorktreesActivitySection({ sessionId, openTransientTab }) {
+	const session = useStore(worktreeActivity.store, (state) => worktreeActivity.select(state, sessionId));
+	if (session.worktrees.length === 0 && session.pending === void 0) return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center gap-2 px-1",
+		children: [/* @__PURE__ */ jsx("p", {
+			"data-testid": "activity-summary-git",
+			className: "px-1 text-xs text-doom-faint",
+			children: "idle"
+		}), sessionId === null ? null : /* @__PURE__ */ jsx(Button, {
+			variant: "link",
+			size: "xs",
+			"data-testid": "activity-git-create",
+			className: "px-0",
+			onClick: () => openTransientTab(worktreesTab()),
+			children: "create a worktree"
+		})]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "activity-git-worktrees",
+		className: "flex flex-col gap-0.5",
+		children: [session.pending === void 0 ? null : /* @__PURE__ */ jsxs("span", {
+			className: "flex min-w-0 items-center gap-1.5 px-1",
+			children: [/* @__PURE__ */ jsx(Spinner, {
+				className: "h-3 w-3 shrink-0 text-doom-faint",
+				label: session.pending
+			}), /* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate text-xs text-doom-dim",
+				children: session.pending
+			})]
+		}), session.worktrees.map((worktree) => /* @__PURE__ */ jsx(Button, {
+			variant: "ghost",
+			size: "card",
+			"data-testid": `activity-git-worktree-${worktree.id}`,
+			className: "min-w-0 gap-1.5 px-1",
+			onClick: () => openTransientTab(worktreesTab()),
+			children: /* @__PURE__ */ jsxs("span", {
+				className: "flex w-full min-w-0 items-center gap-1.5",
+				children: [
+					/* @__PURE__ */ jsx(Dot, { tone: worktree.orphaned ? "red" : worktree.sessionId === null ? "muted" : "blue" }),
+					/* @__PURE__ */ jsx("span", {
+						className: "min-w-0 flex-1 truncate text-left text-xs font-bold text-doom-hi",
+						children: worktree.branch
+					}),
+					worktree.orphaned ? /* @__PURE__ */ jsx(StatusBadge, {
+						tone: "error",
+						size: "xs",
+						children: "orphaned"
+					}) : null,
+					worktree.unowned ? /* @__PURE__ */ jsx(StatusBadge, {
+						tone: "info",
+						size: "xs",
+						children: "unowned"
+					}) : null
+				]
+			})
+		}, worktree.id))]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Worktrees.activity.git.web.tsx
+var Worktrees_activity_git_web_default = defineFill({ component: WorktreesActivitySection });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/start.web.ts
+var start_web_default = defineWebLifecycle(startWorktreeRuntime);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/_components/RunWorktreeToolMessage.tsx
+const ACTION_LABEL = {
+	spawn_worktree: "Create worktree",
+	close_worktree: "Close worktree",
+	list: "List worktrees",
+	status: "Worktree status",
+	merge: "Merge worktree",
+	prune: "Prune worktrees",
+	send: "Message worktree",
+	messages: "Read worktree messages"
+};
+/**
+* The timeline item for `run_worktree`.
+*
+* DESIGN PATTERNS:
+* - Built on MessageItem, like every other tool renderer in the cockpit. That
+*   is what gives it the shared collapse toggle and the RUNNING/OK/ERROR badge
+*   rather than a hand-rolled ellipsis that never resolves.
+* - The action and its subject go in the heading because that is what a reader
+*   scanning a transcript needs: "close_worktree a1b2c3d4" answers the question
+*   the raw JSON arguments make them decode.
+* - A create takes as long as the cockpit needs to start a session, and the
+*   tool streams each phase into `output`, so the body is where the wait is
+*   visible.
+*/
+function RunWorktreeToolMessage({ args, output, running, isError }) {
+	const action = typeof args.action === "string" ? args.action : "";
+	const subject = typeof args.branch === "string" ? args.branch : typeof args.id === "string" ? args.id : "";
+	return /* @__PURE__ */ jsxs(MessageItem, {
+		tone: toolTone({
+			running,
+			isError
+		}),
+		expandable: output !== "",
+		children: [/* @__PURE__ */ jsx(MessageItemHeader, {
+			title: ACTION_LABEL[action] ?? "Worktree",
+			children: subject === "" ? null : /* @__PURE__ */ jsx("span", {
+				className: "min-w-0 truncate text-doom-dim",
+				children: subject
+			})
+		}), output === "" ? null : /* @__PURE__ */ jsx(MessageItemBody, { children: /* @__PURE__ */ jsx("pre", {
+			className: `whitespace-pre-wrap text-xs ${isError ? "text-doom-red" : "text-doom-dim"}`,
+			children: output
+		}) })]
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/tool/runWorktree.web.tsx
+var runWorktree_web_default = defineToolRenderer({ message: RunWorktreeToolMessage });
+//#endregion
+//#region generated/web.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const webPlugin = defineWebPlugin({
+	id: "git",
+	workspace: { get fills() {
+		return [via({
+			slot: "new-session",
+			id: "git-new-session"
+		}, GitNewSession_new_session_web_default)];
+	} },
+	session: {
+		get activityGroups() {
+			return [via({ name: "git" }, git_web_default)];
+		},
+		get channels() {
+			return [via({ channel: "git_worktrees" }, gitWorktrees_web_default)];
+		},
+		get fills() {
+			return [
+				via({
+					slot: "session-menu",
+					id: "worktree"
+				}, Worktree_session_menu_web_default),
+				via({
+					slot: "overlay",
+					id: "worktree-create"
+				}, WorktreeCreate_overlay_web_default),
+				via({
+					slot: "activity.git",
+					id: "worktrees"
+				}, Worktrees_activity_git_web_default)
+			];
+		},
+		get start() {
+			return start_web_default;
+		},
+		get toolRenderers() {
+			return [via({ tools: ["run_worktree"] }, runWorktree_web_default)];
+		}
+	}
+});
+//#endregion
+export { webPlugin };
+
+//# sourceMappingURL=web.mjs.map