@agimon-ai/po-git 0.0.0-alpha.0 → 0.0.0-alpha.10

package/dist/extensions/native.mjs

@@ -0,0 +1,1079 @@
+import { createApiClient, defineActivityGroup, defineChannelFile, defineFill, defineGlobalStore, defineNativePlugin, defineSessionStore, defineWebLifecycle, nativeApiTransport, sessionApiAddress } from "@agimon-ai/po-core/native";
+import { BranchIcon, Button, Dot, Input, ListRow, Sheet, SheetBody, SheetContent, SheetHeader, SheetTitle, Textarea, fontOf } from "@agimon-ai/po-native-components";
+import { createElement, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { View } from "react-native-unistyles/components/native/View";
+import { Text } from "react-native-unistyles/components/native/Text";
+import { ScrollView } from "react-native-unistyles/components/native/ScrollView";
+import { StyleSheet } from "react-native-unistyles";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#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.native.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$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalText$1(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function optionalErrorTarget$1(value) {
+	if (!isRecord$2(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$2(input) || !Array.isArray(input.worktrees)) return null;
+		return {
+			worktrees: input.worktrees.filter(isRecord$2),
+			pending: optionalText$1(input.pending),
+			error: optionalText$1(input.error),
+			errorTarget: optionalErrorTarget$1(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.native.tsx
+function useWorktrees(sessionId) {
+	const subscribe = useCallback((listener) => {
+		const sub = worktreeActivity.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	return useSyncExternalStore(subscribe, () => worktreeActivity.select(worktreeActivity.store.state, sessionId));
+}
+function worktreesTab() {
+	return {
+		id: "git-worktrees",
+		label: "worktrees",
+		panel: WorktreesPanel
+	};
+}
+function WorktreesPanel({ sessionId, sessionReservationId, openSession }) {
+	const state = useWorktrees(sessionId);
+	const [creating, setCreating] = useState(false);
+	const [branch, setBranch] = useState("");
+	const [baseRef, setBaseRef] = useState("");
+	const [closing, setClosing] = useState();
+	const busy = state.pending !== void 0;
+	return /* @__PURE__ */ jsxs(ScrollView, {
+		contentContainerStyle: styles$1.body,
+		children: [
+			/* @__PURE__ */ jsx(Button, {
+				testID: "git-worktree-create",
+				disabled: sessionId === null || busy,
+				onPress: () => setCreating(true),
+				children: "Create a worktree"
+			}),
+			state.pending ? /* @__PURE__ */ jsx(Text, {
+				style: styles$1.meta,
+				children: state.pending
+			}) : null,
+			state.error ? /* @__PURE__ */ jsx(Text, {
+				style: styles$1.error,
+				children: state.error
+			}) : null,
+			state.worktrees.map((worktree) => /* @__PURE__ */ jsxs(View, {
+				style: styles$1.card,
+				children: [
+					/* @__PURE__ */ jsx(ListRow, {
+						title: worktree.branch,
+						description: `${worktree.path}${worktree.orphaned ? "\nOrphaned" : ""}${worktree.unowned ? "\nUnowned" : ""}`
+					}),
+					worktree.sessionId && openSession ? /* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						onPress: () => openSession(worktree.sessionId),
+						children: "Open session"
+					}) : null,
+					/* @__PURE__ */ jsx(Button, {
+						variant: "danger-outline",
+						disabled: sessionId === null || busy,
+						testID: `git-worktree-close-${worktree.id}`,
+						onPress: () => setClosing(worktree.id),
+						children: "Close worktree"
+					})
+				]
+			}, worktree.id)),
+			state.worktrees.length === 0 ? /* @__PURE__ */ jsx(Text, {
+				style: styles$1.meta,
+				children: "No worktrees yet. A worktree is its own checkout, branch and session."
+			}) : null,
+			/* @__PURE__ */ jsx(Sheet, {
+				open: creating,
+				onOpenChange: setCreating,
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: "Create a worktree" }) }), /* @__PURE__ */ jsx(SheetBody, { children: /* @__PURE__ */ jsxs(View, {
+					style: styles$1.body,
+					children: [
+						/* @__PURE__ */ jsx(Input, {
+							accessibilityLabel: "Branch",
+							placeholder: "wt/fix-auth",
+							value: branch,
+							onChangeText: setBranch
+						}),
+						/* @__PURE__ */ jsx(Input, {
+							accessibilityLabel: "Base ref",
+							placeholder: "Base (current)",
+							value: baseRef,
+							onChangeText: setBaseRef
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							style: styles$1.meta,
+							children: "Creates the worktree outside the repository and starts a session nested under this one."
+						}),
+						/* @__PURE__ */ jsx(Button, {
+							disabled: sessionId === null || busy || branch.trim() === "",
+							onPress: () => {
+								if (sessionId === null) return;
+								requestWorktreeCreate(sessionId, branch, baseRef, sessionReservationId);
+								setCreating(false);
+								if (sessionReservationId === void 0) {
+									setBranch("");
+									setBaseRef("");
+								}
+							},
+							children: "Create"
+						})
+					]
+				}) })] })
+			}),
+			/* @__PURE__ */ jsx(Sheet, {
+				open: closing !== void 0,
+				onOpenChange: (open) => {
+					if (!open) setClosing(void 0);
+				},
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: "Close this worktree?" }) }), /* @__PURE__ */ jsxs(SheetBody, { children: [/* @__PURE__ */ jsx(Text, {
+					style: styles$1.meta,
+					children: "The checkout is removed. Git refuses a dirty worktree."
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					disabled: busy,
+					onPress: () => {
+						if (sessionId !== null && closing !== void 0) requestWorktreeClose(sessionId, closing);
+						setClosing(void 0);
+					},
+					children: "Close worktree"
+				})] })] })
+			})
+		]
+	});
+}
+const styles$1 = StyleSheet.create((theme) => ({
+	body: {
+		padding: theme.spacing(3),
+		gap: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	card: {
+		borderWidth: 1,
+		borderColor: theme.colors["border-soft"],
+		borderRadius: theme.borderRadius.md,
+		backgroundColor: theme.colors.panel,
+		padding: theme.spacing(2),
+		gap: theme.spacing(1),
+		uni__dependencies: [0]
+	},
+	meta: {
+		color: theme.colors.dim,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	},
+	error: {
+		color: theme.colors.red,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	}
+}));
+//#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/workspaces/sessions/(frontend)/_lib/gitChangesStore.native.ts
+/**
+* This session's code change against its base, and the manual sync beside it.
+*
+* DESIGN PATTERNS:
+* - Its own session store and hub channel, apart from worktrees. Worktrees are
+*   repository management; this is the session's diff.
+* - The hub is authoritative: it computes the counts, runs pull, push and
+*   rebase one at a time, and reports pending, errors and a paused rebase here.
+* - 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:
+* - `sendSessionFrame` for a sync command. That frame is bound for the agent
+*   and never reaches a channel's `receive`.
+*/
+const gitChanges = defineSessionStore({
+	changes: void 0,
+	pending: void 0,
+	error: void 0,
+	errorTarget: void 0
+});
+/** The page's hub socket sender; undefined before start and after dispose, when a command is dropped. */
+const changesSender = defineGlobalStore(void 0);
+/** Binds the page's hub socket for sync commands. The plugin host calls this once per page. */
+function startGitChangesRuntime(runtime) {
+	const send = (frame) => {
+		runtime.sendHubFrame(frame);
+	};
+	changesSender.update(() => send);
+	return () => {
+		changesSender.update((current) => current === send ? void 0 : current);
+	};
+}
+/** Whether a sync command is running for this session. */
+const gitChangesActivitySource = {
+	subscribe(listener) {
+		const subscription = gitChanges.store.subscribe(listener);
+		return () => subscription.unsubscribe();
+	},
+	isActive(sessionId) {
+		return gitChanges.select(gitChanges.store.state, sessionId).pending !== void 0;
+	}
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalText(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function count(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+/** The page never trusts a frame's shape: a malformed field drops, the rest still renders. */
+const MAX_CONFLICTS = 100;
+function optionalChanges(value) {
+	if (!isRecord$1(value)) return void 0;
+	const added = count(value.added);
+	const removed = count(value.removed);
+	const files = count(value.files);
+	if (added === void 0 || removed === void 0 || files === void 0) return void 0;
+	const branch = optionalText(value.branch);
+	const base = optionalText(value.base);
+	const upstream = isRecord$1(value.upstream) ? value.upstream : void 0;
+	const ahead = count(upstream?.ahead);
+	const behind = count(upstream?.behind);
+	const upstreamRef = optionalText(upstream?.ref);
+	const conflicts = isRecord$1(value.rebase) && Array.isArray(value.rebase.conflicts) ? value.rebase.conflicts.filter((file) => typeof file === "string").slice(0, MAX_CONFLICTS) : void 0;
+	return {
+		added,
+		removed,
+		files,
+		...branch === void 0 ? {} : { branch },
+		...base === void 0 ? {} : { base },
+		...value.truncated === true ? { truncated: true } : {},
+		...upstreamRef === void 0 || ahead === void 0 || behind === void 0 ? {} : { upstream: {
+			ref: upstreamRef,
+			ahead,
+			behind
+		} },
+		...conflicts === void 0 ? {} : { rebase: { conflicts } }
+	};
+}
+function optionalErrorTarget(value) {
+	if (!isRecord$1(value)) return void 0;
+	if (value.action === "pull" || value.action === "rebase" || value.action === "abort-rebase") return { action: value.action };
+	if (value.action === "push") return value.forceRequired === true ? {
+		action: "push",
+		forceRequired: true
+	} : { action: "push" };
+}
+/** The session data channel: 'git_changes' payloads into the store. */
+const gitChangesChannel = gitChanges.channel({
+	channel: GIT_CHANGES_TYPE,
+	parse(input) {
+		if (!isRecord$1(input)) return null;
+		return {
+			changes: optionalChanges(input.changes),
+			pending: optionalText(input.pending),
+			error: optionalText(input.error),
+			errorTarget: optionalErrorTarget(input.errorTarget)
+		};
+	},
+	reduce(_current, next) {
+		return next;
+	}
+});
+/**
+* Asks the hub to pull, push, rebase or abort a paused rebase. `force` is only
+* ever sent after the reader confirmed a lease force for a rejected push.
+*/
+function requestGitSync(sessionId, action, force = false) {
+	const payload = action === "push" && force ? {
+		action: "push",
+		force: true
+	} : { action };
+	changesSender.store.state?.({
+		type: GIT_CHANGES_TYPE,
+		sessionId,
+		payload
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/activity-group/git.native.ts
+var git_native_default = defineActivityGroup({
+	keys: "g w",
+	icon: () => createElement(BranchIcon),
+	activeSource: {
+		subscribe(listener) {
+			const stopWorktrees = worktreeActivitySource.subscribe(listener);
+			const stopChanges = gitChangesActivitySource.subscribe(listener);
+			return () => {
+				stopWorktrees();
+				stopChanges();
+			};
+		},
+		isActive(sessionId) {
+			return worktreeActivitySource.isActive(sessionId) || gitChangesActivitySource.isActive(sessionId);
+		}
+	},
+	marksBackgroundWork: false,
+	transientTab: worktreesTab,
+	order: 30
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/git-changes.native.ts
+var git_changes_native_default = defineChannelFile(gitChangesChannel);
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/channel/git-worktrees.native.ts
+var git_worktrees_native_default = defineChannelFile(worktreesChannel);
+const api = createApiClient({
+	/** Workspace: the new-session dialog's branch list. */
+	branches: {
+		method: "GET",
+		path: "/branches",
+		response: void 0
+	},
+	/** Workspace: a top-level worktree session on an existing or new branch. */
+	createSession: {
+		method: "POST",
+		path: "/sessions",
+		response: void 0
+	},
+	/** Workspace: that workspace's saved remote auth, never the token itself. */
+	auth: {
+		method: "GET",
+		path: "/auth",
+		query: ["repositoryId"],
+		response: void 0
+	},
+	/** Workspace: replaces that workspace's remote auth. Passkey step-up gated for remote devices. */
+	saveAuth: {
+		method: "PUT",
+		path: "/auth",
+		query: ["repositoryId"],
+		response: void 0
+	},
+	/** Session: the files this session's checkout changed against its base. */
+	review: {
+		method: "GET",
+		path: "/review",
+		response: void 0
+	},
+	/** Session: one changed file's hunks. */
+	reviewFile: {
+		method: "GET",
+		path: "/review/file",
+		query: ["path"],
+		response: void 0
+	}
+}, {
+	scopes: [
+		"global",
+		"workspace",
+		"session"
+	],
+	basePath: "git",
+	transport: nativeApiTransport,
+	sessionAddress: sessionApiAddress
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/gitReviewApi.native.ts
+/**
+* The review tab's half of the session API: the changed-file list and one
+* file's hunks.
+*
+* The generated client owns the URL and the sealed transport, so nothing here
+* spells a route or reaches for `fetch`. What travels is file contents, which a
+* tunnel's relay must never see in the clear.
+*/
+const UNREACHABLE = "The session is unreachable.";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The message a reader is shown: the route's own words, or why there were none. */
+function messageOf(result) {
+	if (result.status === 0) return UNREACHABLE;
+	return result.error === "" ? `The session answered ${String(result.status)}.` : result.error;
+}
+async function fetchReviewSummary(sessionId, signal) {
+	const result = await api.session(sessionId).review(signal === void 0 ? {} : { signal });
+	if (!result.ok) return {
+		ok: false,
+		error: messageOf(result)
+	};
+	if (!isRecord(result.data) || !Array.isArray(result.data.files)) return {
+		ok: false,
+		error: "The session answered with no file list."
+	};
+	return {
+		ok: true,
+		summary: result.data
+	};
+}
+async function fetchReviewFile(sessionId, path, signal) {
+	const result = await api.session(sessionId).reviewFile({
+		query: { path },
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!result.ok) return {
+		ok: false,
+		error: messageOf(result)
+	};
+	if (!isRecord(result.data) || !Array.isArray(result.data.hunks)) return {
+		ok: false,
+		error: "The session answered with no diff."
+	};
+	return {
+		ok: true,
+		diff: result.data
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/gitReviewStore.native.ts
+const gitReview = defineSessionStore({ comments: [] });
+function addReviewComment(sessionId, comment) {
+	const id = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+	gitReview.update(sessionId, (current) => ({ comments: [...current.comments, {
+		...comment,
+		id
+	}] }));
+}
+function removeReviewComment(sessionId, id) {
+	gitReview.update(sessionId, (current) => ({ comments: current.comments.filter((comment) => comment.id !== id) }));
+}
+function clearReviewComments(sessionId) {
+	gitReview.update(sessionId, () => ({ comments: [] }));
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_lib/gitReviewView.ts
+/**
+* Pure wording for what the review tab sends the agent, and the one send.
+*
+* Both messages go as `follow_up`: the host starts a turn when idle, or after
+* the current one, without treating a review send as an explicit Queue action.
+* A `prompt` frame instead fails while a turn runs.
+*/
+/** The opening line of a review, naming what was reviewed. */
+function reviewHeading(count, branch, base) {
+	return `I reviewed ${branch === void 0 ? "this checkout" : `branch ${branch}`} (${base === void 0 ? "its uncommitted changes" : `its changes against ${base}`}) and left ${count === 1 ? "one review comment" : `${String(count)} review comments`}. ${count === 1 ? "Please address it." : "Please address them all."}`;
+}
+/** What "ask agent to resolve" sends: the files, and the steps that finish a paused rebase. */
+function conflictPrompt(branch, conflicts) {
+	const files = conflicts.length === 0 ? "- (git reports no unmerged paths yet)" : conflicts.map((file) => `- ${file}`).join("\n");
+	return [
+		`A rebase of ${branch ?? "this checkout"} stopped on conflicts in:`,
+		"",
+		files,
+		"",
+		"Please resolve them:",
+		"1. Fix the conflict markers in each file, keeping the intent of both sides.",
+		"2. `git add` each resolved file.",
+		"3. Run `GIT_EDITOR=true git rebase --continue`, and repeat if it stops again.",
+		"",
+		"Do not push. I will push from the cockpit once the rebase is done."
+	].join("\n");
+}
+/**
+* Hands one deferred follow-up to the session. Returns the reason it failed,
+* or undefined once sent. The sender throws when the session is disconnected.
+*/
+function deliverToAgent(send, sessionId, message) {
+	try {
+		send(sessionId, {
+			type: "follow_up",
+			message
+		});
+		return;
+	} catch (error) {
+		return error instanceof Error ? error.message : "The session did not take the message.";
+	}
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/_components/GitReviewPanel.native.tsx
+function useGitChanges(sessionId) {
+	const subscribe = useCallback((listener) => {
+		const sub = gitChanges.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	return useSyncExternalStore(subscribe, () => gitChanges.select(gitChanges.store.state, sessionId));
+}
+function reviewTab() {
+	return {
+		id: "git-review",
+		label: "review",
+		panel: GitReviewPanel
+	};
+}
+function GitReviewPanel({ sessionId, sendSessionFrame }) {
+	const activity = useGitChanges(sessionId);
+	const subscribe = useCallback((listener) => {
+		const sub = gitReview.store.subscribe(listener);
+		return () => sub.unsubscribe();
+	}, []);
+	const comments = useSyncExternalStore(subscribe, () => gitReview.select(gitReview.store.state, sessionId).comments);
+	const [summary, setSummary] = useState();
+	const [file, setFile] = useState();
+	const [error, setError] = useState();
+	const [dismissedError, setDismissedError] = useState();
+	const [confirm, setConfirm] = useState();
+	const [draft, setDraft] = useState();
+	const [comment, setComment] = useState("");
+	const [start, setStart] = useState("");
+	const [end, setEnd] = useState("");
+	const request = useRef(void 0);
+	const fingerprint = JSON.stringify(activity.changes);
+	useEffect(() => {
+		if (sessionId === null) return void 0;
+		const controller = new AbortController();
+		fetchReviewSummary(sessionId, controller.signal).then((result) => {
+			if (!controller.signal.aborted) {
+				if (result.ok) setSummary(result.summary);
+				else setError(result.error);
+			}
+		}).catch((cause) => {
+			if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause));
+		});
+		return () => {
+			controller.abort();
+			request.current?.abort();
+		};
+	}, [sessionId, fingerprint]);
+	const loadFile = async (path) => {
+		if (sessionId === null) return;
+		request.current?.abort();
+		const controller = new AbortController();
+		request.current = controller;
+		setFile(void 0);
+		setError(void 0);
+		try {
+			const result = await fetchReviewFile(sessionId, path, controller.signal);
+			if (!controller.signal.aborted) {
+				if (result.ok) setFile(result.diff);
+				else setError(result.error);
+			}
+		} catch (cause) {
+			if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : String(cause));
+		}
+	};
+	if (sessionId === null) return null;
+	const changes = activity.changes;
+	const busy = activity.pending !== void 0;
+	const paused = changes?.rebase !== void 0;
+	const send = (message, onSent) => {
+		const failure = deliverToAgent(sendSessionFrame, sessionId, message);
+		setError(failure);
+		if (failure === void 0) onSent?.();
+	};
+	const sync = (action) => requestGitSync(sessionId, action);
+	const forceRequired = activity.error !== dismissedError && activity.errorTarget?.action === "push" && activity.errorTarget.forceRequired === true;
+	return /* @__PURE__ */ jsxs(ScrollView, {
+		contentContainerStyle: styles.body,
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				style: styles.title,
+				children: changes?.branch ?? "Detached HEAD"
+			}),
+			/* @__PURE__ */ jsxs(Text, {
+				style: styles.meta,
+				children: [
+					changes?.base ? `vs ${changes.base}` : "Uncommitted changes",
+					" · +",
+					changes?.added ?? 0,
+					" -",
+					changes?.removed ?? 0,
+					"\\n",
+					changes?.upstream ? `↑${changes.upstream.ahead} ↓${changes.upstream.behind} ${changes.upstream.ref}` : "No upstream yet"
+				]
+			}),
+			/* @__PURE__ */ jsxs(View, {
+				style: styles.actions,
+				children: [
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						disabled: busy || paused || changes?.upstream === void 0,
+						onPress: () => sync("pull"),
+						children: "Pull"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						disabled: busy || paused || changes?.branch === void 0,
+						onPress: () => sync("push"),
+						children: "Push"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						disabled: busy || paused || changes?.base === void 0,
+						onPress: () => sync("rebase"),
+						children: "Rebase"
+					})
+				]
+			}),
+			activity.pending ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: activity.pending
+			}) : null,
+			activity.error && activity.error !== dismissedError ? /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: activity.error
+			}), /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				onPress: () => setDismissedError(activity.error),
+				children: "Dismiss"
+			})] }) : null,
+			forceRequired ? /* @__PURE__ */ jsx(Button, {
+				variant: "danger-outline",
+				disabled: busy,
+				onPress: () => setConfirm("force"),
+				children: "Force push with lease…"
+			}) : null,
+			paused ? /* @__PURE__ */ jsxs(View, {
+				style: styles.body,
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						style: styles.error,
+						children: ["Rebase paused\\n", changes.rebase?.conflicts.join("\n")]
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						disabled: busy,
+						onPress: () => send(conflictPrompt(changes.branch, changes.rebase?.conflicts ?? [])),
+						children: "Ask agent to resolve"
+					}),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "danger-outline",
+						disabled: busy,
+						onPress: () => setConfirm("abort"),
+						children: "Abort rebase…"
+					})
+				]
+			}) : null,
+			error ? /* @__PURE__ */ jsx(Text, {
+				style: styles.error,
+				children: error
+			}) : null,
+			summary ? summary.files.map((entry) => /* @__PURE__ */ jsxs(Button, {
+				variant: "ghost",
+				testID: `git-review-file-${entry.path}`,
+				onPress: () => void loadFile(entry.path),
+				children: [
+					entry.path,
+					" · ",
+					entry.status,
+					" · +",
+					entry.added,
+					" -",
+					entry.removed
+				]
+			}, entry.path)) : /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "Loading changes…"
+			}),
+			summary?.files.length === 0 ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: summary.repository ? "No changed files" : "Not a Git checkout"
+			}) : null,
+			summary?.truncated ? /* @__PURE__ */ jsx(Text, {
+				style: styles.meta,
+				children: "The file list was truncated."
+			}) : null,
+			file ? /* @__PURE__ */ jsxs(View, {
+				style: styles.body,
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						style: styles.title,
+						children: file.path
+					}),
+					file.binary || file.tooLarge ? /* @__PURE__ */ jsx(Text, {
+						style: styles.meta,
+						children: file.binary ? "Binary file" : "Diff too large to display"
+					}) : file.hunks.map((hunk, index) => /* @__PURE__ */ jsx(View, { children: hunk.rows.map((row, rowIndex) => /* @__PURE__ */ jsxs(Text, {
+						selectable: true,
+						style: styles.diff(row.marker),
+						onPress: () => {
+							setDraft({
+								path: file.path,
+								rows: hunk.rows
+							});
+							setStart(String(row.line));
+							setEnd(String(row.line));
+						},
+						children: [
+							row.marker,
+							" ",
+							row.line,
+							" ",
+							row.content
+						]
+					}, rowIndex)) }, index)),
+					/* @__PURE__ */ jsx(Button, {
+						variant: "outline",
+						onPress: () => {
+							setDraft({
+								path: file.path,
+								rows: []
+							});
+							setStart("");
+							setEnd("");
+						},
+						children: "Comment on file"
+					})
+				]
+			}) : null,
+			comments.map((item) => /* @__PURE__ */ jsxs(View, { children: [/* @__PURE__ */ jsxs(Text, {
+				style: styles.meta,
+				children: [
+					item.relPath,
+					item.startLine === void 0 ? "" : `:${item.startLine}-${item.endLine ?? item.startLine}`,
+					"\\n",
+					item.body
+				]
+			}), /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				onPress: () => removeReviewComment(sessionId, item.id),
+				children: "Remove comment"
+			})] }, item.id)),
+			comments.length > 0 ? /* @__PURE__ */ jsxs(View, {
+				style: styles.actions,
+				children: [/* @__PURE__ */ jsx(Button, {
+					onPress: () => {
+						const body = comments.map((item) => {
+							return `### ${item.startLine === void 0 ? item.relPath : item.side === "old" ? `${item.relPath} (removed lines ${item.startLine}-${item.endLine ?? item.startLine})` : `${item.relPath}:${item.startLine}-${item.endLine ?? item.startLine}`}\n\n${item.snippet.split("\n").slice(0, 20).join("\n").slice(0, 2e3).split("\n").map((line) => `> ${line}`).join("\n")}\n\n${item.body.trim()}`;
+						}).join("\n\n");
+						send(`${reviewHeading(comments.length, summary?.branch, summary?.base)}\n\n${body}`, () => clearReviewComments(sessionId));
+					},
+					children: "Send review"
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					onPress: () => setConfirm("discard"),
+					children: "Discard review…"
+				})]
+			}) : null,
+			/* @__PURE__ */ jsx(Sheet, {
+				open: draft !== void 0,
+				onOpenChange: (open) => {
+					if (!open) setDraft(void 0);
+				},
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: "Review comment" }) }), /* @__PURE__ */ jsx(SheetBody, { children: /* @__PURE__ */ jsxs(View, {
+					style: styles.body,
+					children: [
+						draft?.rows.length ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Input, {
+							accessibilityLabel: "Start line",
+							value: start,
+							onChangeText: setStart,
+							keyboardType: "number-pad"
+						}), /* @__PURE__ */ jsx(Input, {
+							accessibilityLabel: "End line",
+							value: end,
+							onChangeText: setEnd,
+							keyboardType: "number-pad"
+						})] }) : null,
+						/* @__PURE__ */ jsx(Textarea, {
+							accessibilityLabel: "Comment",
+							value: comment,
+							onChangeText: setComment
+						}),
+						/* @__PURE__ */ jsx(Button, {
+							disabled: comment.trim() === "" || Boolean(draft?.rows.length) && (!Number.isInteger(Number(start)) || Number(start) < 1 || !Number.isInteger(Number(end)) || Number(end) < Number(start)),
+							onPress: () => {
+								if (!draft) return;
+								const rows = draft.rows.filter((row) => row.line >= Number(start) && row.line <= Number(end));
+								const kept = rows.filter((row) => row.marker !== "-");
+								const numbered = kept.length > 0 ? kept : rows;
+								addReviewComment(sessionId, {
+									path: draft.path,
+									relPath: draft.path,
+									body: comment.trim(),
+									snippet: numbered.map((row) => row.content).join("\n"),
+									...numbered.length === 0 ? {} : {
+										side: kept.length > 0 ? "new" : "old",
+										startLine: Math.min(...numbered.map((row) => row.line)),
+										endLine: Math.max(...numbered.map((row) => row.line))
+									}
+								});
+								setDraft(void 0);
+								setComment("");
+							},
+							children: "Add comment"
+						})
+					]
+				}) })] })
+			}),
+			/* @__PURE__ */ jsx(Sheet, {
+				open: confirm !== void 0,
+				onOpenChange: (open) => {
+					if (!open) setConfirm(void 0);
+				},
+				children: /* @__PURE__ */ jsxs(SheetContent, { children: [/* @__PURE__ */ jsx(SheetHeader, { children: /* @__PURE__ */ jsx(SheetTitle, { children: confirm === "force" ? "Force push with lease?" : confirm === "abort" ? "Abort rebase?" : "Discard review?" }) }), /* @__PURE__ */ jsxs(SheetBody, { children: [/* @__PURE__ */ jsx(Text, {
+					style: styles.meta,
+					children: confirm === "force" ? "Git refuses this if the remote holds commits you never fetched and integrated." : confirm === "abort" ? "Abort discards any conflict resolution in progress." : "Your queued comments will be removed."
+				}), /* @__PURE__ */ jsx(Button, {
+					variant: "danger-outline",
+					onPress: () => {
+						if (confirm === "force") requestGitSync(sessionId, "push", true);
+						else if (confirm === "abort") sync("abort-rebase");
+						else clearReviewComments(sessionId);
+						setConfirm(void 0);
+					},
+					children: "Confirm"
+				})] })] })
+			})
+		]
+	});
+}
+const styles = StyleSheet.create((theme) => ({
+	body: {
+		padding: theme.spacing(3),
+		gap: theme.spacing(2),
+		uni__dependencies: [0]
+	},
+	actions: {
+		flexDirection: "row",
+		flexWrap: "wrap",
+		gap: theme.spacing(1),
+		uni__dependencies: [0]
+	},
+	title: {
+		color: theme.colors.hi,
+		fontSize: theme.fontSize.base,
+		fontWeight: "600",
+		uni__dependencies: [0]
+	},
+	meta: {
+		color: theme.colors.dim,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	},
+	error: {
+		color: theme.colors.red,
+		fontSize: theme.fontSize.sm,
+		uni__dependencies: [0]
+	},
+	diff: (marker) => ({
+		fontFamily: fontOf(theme.fontFamily.mono),
+		fontSize: theme.fontSize.sm,
+		color: marker === "+" ? theme.colors.green : marker === "-" ? theme.colors.red : theme.colors.text,
+		paddingVertical: theme.spacing(1),
+		uni__dependencies: [0]
+	})
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/_components/WorktreesActivitySection.native.tsx
+function WorktreesActivitySection({ sessionId, openTransientTab }) {
+	const git = useGitChanges(sessionId);
+	const state = useWorktrees(sessionId);
+	const worktrees = state.worktrees.filter((item) => item.sessionId !== sessionId);
+	return /* @__PURE__ */ jsxs(View, { children: [
+		git.changes ? /* @__PURE__ */ jsxs(Button, {
+			variant: "ghost",
+			testID: "activity-diff-changes",
+			onPress: () => openTransientTab(reviewTab()),
+			children: [
+				git.changes.branch ?? "Detached HEAD",
+				" · +",
+				git.changes.added,
+				" -",
+				git.changes.removed
+			]
+		}) : null,
+		state.pending ? /* @__PURE__ */ jsx(ListRow, { title: state.pending }) : null,
+		worktrees.map((item) => /* @__PURE__ */ jsx(ListRow, {
+			leading: /* @__PURE__ */ jsx(Dot, { tone: item.orphaned ? "red" : item.sessionId === null ? "muted" : "blue" }),
+			title: /* @__PURE__ */ jsx(Button, {
+				variant: "ghost",
+				onPress: () => openTransientTab(worktreesTab()),
+				children: item.branch
+			}),
+			description: [item.orphaned ? "Orphaned" : "", item.unowned ? "Unowned" : ""].filter(Boolean).join(" · ")
+		}, item.id)),
+		worktrees.length === 0 && state.pending === void 0 ? /* @__PURE__ */ jsx(Button, {
+			variant: "ghost",
+			testID: "activity-git-create",
+			disabled: sessionId === null,
+			onPress: () => openTransientTab(worktreesTab()),
+			children: "Create a worktree"
+		}) : null
+	] });
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/fill/Worktrees.activity.git.native.tsx
+var Worktrees_activity_git_native_default = defineFill({ component: WorktreesActivitySection });
+//#endregion
+//#region src/extensions/workspaces/sessions/(frontend)/lifecycle/start.native.ts
+var start_native_default = defineWebLifecycle((runtime) => {
+	const stopWorktrees = startWorktreeRuntime(runtime);
+	const stopChanges = startGitChangesRuntime(runtime);
+	return () => {
+		stopChanges();
+		stopWorktrees();
+	};
+});
+//#endregion
+//#region generated/native.ts
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const nativePlugin = defineNativePlugin({
+	id: "git",
+	session: {
+		get activityGroups() {
+			return [via({ name: "git" }, git_native_default)];
+		},
+		get channels() {
+			return [via({ channel: "git_changes" }, git_changes_native_default), via({ channel: "git_worktrees" }, git_worktrees_native_default)];
+		},
+		get fills() {
+			return [via({
+				slot: "activity.git",
+				id: "worktrees"
+			}, Worktrees_activity_git_native_default)];
+		},
+		get start() {
+			return start_native_default;
+		}
+	}
+});
+//#endregion
+export { nativePlugin };
+
+//# sourceMappingURL=native.mjs.map