t3code-cli 0.13.0 → 0.14.0

package/dist/client-runtime/state/vcs.js

@@ -0,0 +1,756 @@
+import { $D as flatMap, $r as failure, AO as tapError, Aa as EnvironmentSupervisor, Cv as get, DO as suspend, Dk as seconds, Dr as runStreamInEnvironment, EO as succeed, Ek as min, FE as concat, Fs as WS_METHODS, GT as Defect, Gr as family, HD as as, HE as fromEffect, HO as modifyDelay, Hk as match, Hr as runStream, Hu as GitActionProgressPhase, JS as EnvironmentId, JT as Literals, Jr as setIdleTTL, KE as map, Kr as keepAlive, La as EnvironmentCacheStore, MD as nowUnsafe, ND as toEpochMillis, Na as safeErrorLogAttributes, OO as sync, PE as changes$1, Q as applyGitStatusStreamEvent, QD as fail, QT as String, RO as void_, St as vcsCommandScheduler, Sv as changes, Uk as none, Ur as subscribe, VD as annotateLogs, VE as filterMap, VO as exponential, Vr as request, Wk as some, XT as NullOr, Xr as withLabel, YD as catch_, YO as hasInterruptsOnly, ZD as ensuring, ZE as retry, ZO as squash, ZT as Number, Zr as AtomRegistry, aO as gen, bO as provideService, bk as failVoid, bt as withVcsRefsPersistenceLock, dr as createEnvironmentRpcCommand, eE as TaggedErrorClass, eO as fn, ei as isSuccess, gr as createRuntimeCommand, hr as createEnvironmentSubscriptionAtomFamily, lD as unwrap, lO as logWarning, nE as Union, oD as switchMap, oE as decodeUnknownSync, qE as mapAccum, qO as fail$1, qr as make, rt as isTemporaryWorktreeBranch, tD as runForEach, tE as Tuple, td as GitStackedAction, vt as invalidateCachedVcsRefs, wk as succeed$1, xr as followStreamInEnvironment, xt as vcsCommandConcurrency, yt as vcsRefsCacheStateAtom, zE as empty } from "../../shared.js";
+//#region upstream-t3code/packages/client-runtime/src/state/gitActions.ts
+function buildGitActionProgressStages(input) {
+	const branchStages = input.featureBranch ? ["Preparing feature branch..."] : [];
+	const pushStage = input.pushTarget ? `Pushing to ${input.pushTarget}...` : "Pushing...";
+	const prStages = [
+		"Preparing PR...",
+		"Generating PR content...",
+		"Creating GitHub pull request..."
+	];
+	if (input.action === "push") return [pushStage];
+	if (input.action === "create_pr") return input.shouldPushBeforePr ? [pushStage, ...prStages] : prStages;
+	const commitStages = !(input.action === "commit" || input.hasWorkingTreeChanges) ? [] : input.hasCustomCommitMessage ? ["Committing..."] : ["Generating commit message...", "Committing..."];
+	if (input.action === "commit") return [...branchStages, ...commitStages];
+	if (input.action === "commit_push") return [
+		...branchStages,
+		...commitStages,
+		pushStage
+	];
+	return [
+		...branchStages,
+		...commitStages,
+		pushStage,
+		...prStages
+	];
+}
+function buildMenuItems(gitStatus, isBusy, hasOriginRemote = true) {
+	if (!gitStatus) return [];
+	const hasBranch = gitStatus.refName !== null;
+	const hasChanges = gitStatus.hasWorkingTreeChanges;
+	const hasOpenPr = gitStatus.pr?.state === "open";
+	const isBehind = gitStatus.behindCount > 0;
+	const canPushWithoutUpstream = hasOriginRemote && !gitStatus.hasUpstream;
+	const canCommit = !isBusy && hasChanges;
+	const canPush = !isBusy && hasBranch && !hasChanges && !isBehind && gitStatus.aheadCount > 0 && (gitStatus.hasUpstream || canPushWithoutUpstream);
+	const canCreatePr = !isBusy && hasBranch && !hasChanges && !hasOpenPr && gitStatus.aheadCount > 0 && !isBehind && (gitStatus.hasUpstream || canPushWithoutUpstream);
+	return [
+		{
+			id: "commit",
+			label: "Commit",
+			disabled: !canCommit,
+			icon: "commit",
+			kind: "open_dialog",
+			dialogAction: "commit"
+		},
+		{
+			id: "push",
+			label: "Push",
+			disabled: !canPush,
+			icon: "push",
+			kind: "open_dialog",
+			dialogAction: "push"
+		},
+		hasOpenPr ? {
+			id: "pr",
+			label: "View PR",
+			disabled: !(!isBusy && hasOpenPr),
+			icon: "pr",
+			kind: "open_pr"
+		} : {
+			id: "pr",
+			label: "Create PR",
+			disabled: !canCreatePr,
+			icon: "pr",
+			kind: "open_dialog",
+			dialogAction: "create_pr"
+		}
+	];
+}
+function resolveQuickAction(gitStatus, isBusy, isDefaultBranch = false, hasOriginRemote = true) {
+	if (isBusy) return {
+		label: "Commit",
+		disabled: true,
+		kind: "show_hint",
+		hint: "Git action in progress."
+	};
+	if (!gitStatus) return {
+		label: "Commit",
+		disabled: true,
+		kind: "show_hint",
+		hint: "Git status is unavailable."
+	};
+	const hasBranch = gitStatus.refName !== null;
+	const hasChanges = gitStatus.hasWorkingTreeChanges;
+	const hasOpenPr = gitStatus.pr?.state === "open";
+	const isAhead = gitStatus.aheadCount > 0;
+	const isBehind = gitStatus.behindCount > 0;
+	const isDiverged = isAhead && isBehind;
+	if (!hasBranch) return {
+		label: "Commit",
+		disabled: true,
+		kind: "show_hint",
+		hint: "Create and checkout a branch before pushing or opening a PR."
+	};
+	if (hasChanges) {
+		if (!gitStatus.hasUpstream && !hasOriginRemote) return {
+			label: "Commit",
+			disabled: false,
+			kind: "run_action",
+			action: "commit"
+		};
+		if (hasOpenPr || isDefaultBranch) return {
+			label: "Commit & push",
+			disabled: false,
+			kind: "run_action",
+			action: "commit_push"
+		};
+		return {
+			label: "Commit, push & PR",
+			disabled: false,
+			kind: "run_action",
+			action: "commit_push_pr"
+		};
+	}
+	if (!gitStatus.hasUpstream) {
+		if (!hasOriginRemote) {
+			if (hasOpenPr && !isAhead) return {
+				label: "View PR",
+				disabled: false,
+				kind: "open_pr"
+			};
+			return {
+				label: "Push",
+				disabled: true,
+				kind: "show_hint",
+				hint: "Add an \"origin\" remote before pushing or creating a PR."
+			};
+		}
+		if (!isAhead) {
+			if (hasOpenPr) return {
+				label: "View PR",
+				disabled: false,
+				kind: "open_pr"
+			};
+			return {
+				label: "Push",
+				disabled: true,
+				kind: "show_hint",
+				hint: "No local commits to push."
+			};
+		}
+		if (hasOpenPr || isDefaultBranch) return {
+			label: "Push",
+			disabled: false,
+			kind: "run_action",
+			action: isDefaultBranch ? "commit_push" : "push"
+		};
+		return {
+			label: "Push & create PR",
+			disabled: false,
+			kind: "run_action",
+			action: "create_pr"
+		};
+	}
+	if (isDiverged) return {
+		label: "Sync branch",
+		disabled: true,
+		kind: "show_hint",
+		hint: "Branch has diverged from upstream. Rebase/merge first."
+	};
+	if (isBehind) return {
+		label: "Pull",
+		disabled: false,
+		kind: "run_pull"
+	};
+	if (isAhead) {
+		if (hasOpenPr || isDefaultBranch) return {
+			label: "Push",
+			disabled: false,
+			kind: "run_action",
+			action: isDefaultBranch ? "commit_push" : "push"
+		};
+		return {
+			label: "Push & create PR",
+			disabled: false,
+			kind: "run_action",
+			action: "create_pr"
+		};
+	}
+	if (hasOpenPr && gitStatus.hasUpstream) return {
+		label: "View PR",
+		disabled: false,
+		kind: "open_pr"
+	};
+	return {
+		label: "Commit",
+		disabled: true,
+		kind: "show_hint",
+		hint: "Branch is up to date. No action needed."
+	};
+}
+function getGitActionDisabledReason(input) {
+	const { item, gitStatus, isBusy, hasOriginRemote } = input;
+	if (!item.disabled) return null;
+	if (isBusy) return "Git action in progress.";
+	if (!gitStatus) return "Git status is unavailable.";
+	const hasBranch = gitStatus.refName !== null;
+	const hasChanges = gitStatus.hasWorkingTreeChanges;
+	const hasOpenPr = gitStatus.pr?.state === "open";
+	const isAhead = gitStatus.aheadCount > 0;
+	const isBehind = gitStatus.behindCount > 0;
+	if (item.id === "commit") {
+		if (!hasChanges) return "Worktree is clean. Make changes before committing.";
+		return "Commit is currently unavailable.";
+	}
+	if (item.id === "push") {
+		if (!hasBranch) return "Detached HEAD: checkout a branch before pushing.";
+		if (hasChanges) return "Commit or stash local changes before pushing.";
+		if (isBehind) return "Branch is behind upstream. Pull/rebase before pushing.";
+		if (!gitStatus.hasUpstream && !hasOriginRemote) return "Add an \"origin\" remote before pushing.";
+		if (!isAhead) return "No local commits to push.";
+		return "Push is currently unavailable.";
+	}
+	if (hasOpenPr) return "View PR is currently unavailable.";
+	if (!hasBranch) return "Detached HEAD: checkout a branch before creating a PR.";
+	if (hasChanges) return "Commit local changes before creating a PR.";
+	if (!gitStatus.hasUpstream && !hasOriginRemote) return "Add an \"origin\" remote before creating a PR.";
+	if (!isAhead) return "No local commits to include in a PR.";
+	if (isBehind) return "Branch is behind upstream. Pull/rebase before creating a PR.";
+	return "Create PR is currently unavailable.";
+}
+function requiresDefaultBranchConfirmation(action, isDefaultBranch) {
+	if (!isDefaultBranch) return false;
+	return action === "push" || action === "create_pr" || action === "commit_push" || action === "commit_push_pr";
+}
+function resolveDefaultBranchActionDialogCopy(input) {
+	const branchLabel = input.branchName;
+	const suffix = ` on "${branchLabel}". You can continue on this branch or create a feature branch and run the same action there.`;
+	if (input.action === "push" || input.action === "commit_push") {
+		if (input.includesCommit) return {
+			title: "Commit & push to default branch?",
+			description: `This action will commit and push changes${suffix}`,
+			continueLabel: `Commit & push to ${branchLabel}`
+		};
+		return {
+			title: "Push to default branch?",
+			description: `This action will push local commits${suffix}`,
+			continueLabel: `Push to ${branchLabel}`
+		};
+	}
+	if (input.includesCommit) return {
+		title: "Commit, push & create PR from default branch?",
+		description: `This action will commit, push, and create a PR${suffix}`,
+		continueLabel: "Commit, push & create PR"
+	};
+	return {
+		title: "Push & create PR from default branch?",
+		description: `This action will push local commits and create a PR${suffix}`,
+		continueLabel: "Push & create PR"
+	};
+}
+function resolveThreadBranchUpdate(result) {
+	if (result.branch.status !== "created" || !result.branch.name) return null;
+	return { branch: result.branch.name };
+}
+function resolveLiveThreadBranchUpdate(input) {
+	if (!input.gitStatus) return null;
+	if (input.gitStatus.refName === null && input.threadBranch !== null) return null;
+	if (input.threadBranch === input.gitStatus.refName) return null;
+	if (input.threadBranch !== null && input.gitStatus.refName !== null && !isTemporaryWorktreeBranch(input.threadBranch) && isTemporaryWorktreeBranch(input.gitStatus.refName)) return null;
+	return { branch: input.gitStatus.refName };
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcsAction.ts
+const VcsActionOperation = Literals([
+	"refresh_status",
+	"run_change_request",
+	"pull",
+	"switch_ref",
+	"create_ref",
+	"create_worktree",
+	"init",
+	"publish_repository",
+	"prepare_pull_request_thread"
+]);
+var VcsActionUnavailableError = class extends TaggedErrorClass()("VcsActionUnavailableError", {
+	operation: VcsActionOperation,
+	environmentId: NullOr(EnvironmentId),
+	cwd: NullOr(String)
+}) {
+	get message() {
+		return `Source control operation '${this.operation.replaceAll("_", " ")}' is unavailable.`;
+	}
+};
+var VcsActionRemoteFailureError = class extends TaggedErrorClass()("VcsActionRemoteFailureError", {
+	actionId: String,
+	transportActionId: String,
+	action: GitStackedAction,
+	environmentId: EnvironmentId,
+	cwd: String,
+	phase: NullOr(GitActionProgressPhase),
+	remoteMessageLength: Number
+}) {
+	get message() {
+		const phase = this.phase === null ? "execution" : this.phase;
+		return `Source control action '${this.action}' failed during ${phase}.`;
+	}
+};
+var VcsActionMissingTerminalEventError = class extends TaggedErrorClass()("VcsActionMissingTerminalEventError", {
+	actionId: String,
+	transportActionId: String,
+	action: GitStackedAction,
+	environmentId: EnvironmentId,
+	cwd: String
+}) {
+	get message() {
+		return `Source control action '${this.action}' ended without a terminal result.`;
+	}
+};
+var VcsActionTargetKeyParseError = class extends TaggedErrorClass()("VcsActionTargetKeyParseError", {
+	keyLength: Number,
+	cause: Defect()
+}) {
+	get message() {
+		return `Invalid source control action target key (${this.keyLength} characters).`;
+	}
+};
+const VcsActionExecutionError = Union([VcsActionRemoteFailureError, VcsActionMissingTerminalEventError]);
+const EMPTY_VCS_ACTION_STATE = Object.freeze({
+	isRunning: false,
+	operation: null,
+	actionId: null,
+	action: null,
+	currentLabel: null,
+	currentPhaseLabel: null,
+	hookName: null,
+	lastOutputLine: null,
+	phaseStartedAtMs: null,
+	hookStartedAtMs: null,
+	error: null
+});
+const nowMs = () => toEpochMillis(nowUnsafe());
+let nextLocalActionId = 0;
+const decodeVcsActionTargetKey = decodeUnknownSync(Tuple([EnvironmentId, String]));
+const vcsActionStateAtom = family((key) => {
+	return make(EMPTY_VCS_ACTION_STATE).pipe(keepAlive, withLabel(`vcs-action:${key}`));
+});
+const EMPTY_VCS_ACTION_ATOM = make(EMPTY_VCS_ACTION_STATE).pipe(keepAlive, withLabel("vcs-action:null"));
+function getVcsActionTargetKey(target) {
+	if (target.environmentId === null || target.cwd === null) return null;
+	return JSON.stringify([target.environmentId, target.cwd]);
+}
+function parseVcsActionTargetKey(key) {
+	try {
+		const [environmentId, cwd] = decodeVcsActionTargetKey(JSON.parse(key));
+		return {
+			environmentId,
+			cwd
+		};
+	} catch (cause) {
+		throw new VcsActionTargetKeyParseError({
+			keyLength: key.length,
+			cause
+		});
+	}
+}
+function getVcsActionStateAtom(target) {
+	const key = getVcsActionTargetKey(target);
+	return key === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(key);
+}
+function createLocalActionId() {
+	nextLocalActionId += 1;
+	return `local-vcs-action:${nextLocalActionId}`;
+}
+function beginVcsActionState(input) {
+	const actionId = input.actionId ?? createLocalActionId();
+	const startedAt = nowMs();
+	return {
+		...EMPTY_VCS_ACTION_STATE,
+		isRunning: true,
+		operation: input.operation,
+		actionId,
+		currentLabel: input.label,
+		currentPhaseLabel: input.label,
+		phaseStartedAtMs: startedAt
+	};
+}
+function failVcsActionState(operation, actionId, error) {
+	return {
+		...EMPTY_VCS_ACTION_STATE,
+		operation,
+		actionId,
+		error: error instanceof Error ? error.message : "Source control action failed."
+	};
+}
+function createVcsActionTransportId(target, actionId) {
+	const targetKey = JSON.stringify([target.environmentId, target.cwd]);
+	return `${targetKey.length}:${targetKey}${actionId}`;
+}
+function normalizeVcsActionProgressEvent(target, transportActionId, actionId, event) {
+	if (event.actionId !== transportActionId || event.cwd !== target.cwd) return null;
+	return {
+		...event,
+		actionId
+	};
+}
+function consumeVcsActionProgress(stream, input) {
+	return suspend(() => {
+		let terminalEvent = null;
+		return stream.pipe(runForEach((event) => {
+			const normalized = normalizeVcsActionProgressEvent(input.target, input.transportActionId, input.actionId, event);
+			if (normalized === null) return void_;
+			if (normalized.kind === "action_finished" || normalized.kind === "action_failed") terminalEvent = normalized;
+			return input.onProgress(normalized);
+		}), flatMap(() => {
+			if (terminalEvent?.kind === "action_finished") return succeed(terminalEvent.result);
+			if (terminalEvent?.kind === "action_failed") return fail(new VcsActionRemoteFailureError({
+				actionId: input.actionId,
+				transportActionId: input.transportActionId,
+				action: terminalEvent.action,
+				environmentId: input.target.environmentId,
+				cwd: input.target.cwd,
+				phase: terminalEvent.phase,
+				remoteMessageLength: terminalEvent.message.length
+			}));
+			return fail(new VcsActionMissingTerminalEventError({
+				actionId: input.actionId,
+				transportActionId: input.transportActionId,
+				action: input.action,
+				environmentId: input.target.environmentId,
+				cwd: input.target.cwd
+			}));
+		}));
+	});
+}
+function applyVcsActionProgressEvent(current, event) {
+	if (current.actionId !== event.actionId) return current;
+	const now = nowMs();
+	switch (event.kind) {
+		case "action_started": return {
+			...current,
+			isRunning: true,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			phaseStartedAtMs: now,
+			hookStartedAtMs: null,
+			hookName: null,
+			lastOutputLine: null,
+			error: null
+		};
+		case "phase_started": return {
+			...current,
+			isRunning: true,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			currentLabel: event.label,
+			currentPhaseLabel: event.label,
+			phaseStartedAtMs: now,
+			hookStartedAtMs: null,
+			hookName: null,
+			lastOutputLine: null,
+			error: null
+		};
+		case "hook_started": return {
+			...current,
+			isRunning: true,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			currentLabel: `Running ${event.hookName}...`,
+			hookName: event.hookName,
+			hookStartedAtMs: now,
+			lastOutputLine: null,
+			error: null
+		};
+		case "hook_output": return {
+			...current,
+			isRunning: true,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			lastOutputLine: event.text,
+			error: null
+		};
+		case "hook_finished": return {
+			...current,
+			isRunning: true,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			currentLabel: current.currentPhaseLabel,
+			hookName: null,
+			hookStartedAtMs: null,
+			lastOutputLine: null,
+			error: null
+		};
+		case "action_finished": return {
+			...EMPTY_VCS_ACTION_STATE,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request"
+		};
+		case "action_failed": return {
+			...EMPTY_VCS_ACTION_STATE,
+			actionId: event.actionId,
+			action: event.action,
+			operation: "run_change_request",
+			error: event.message
+		};
+	}
+}
+function createVcsActionManager(runtime) {
+	const runStackedActionCommands = /* @__PURE__ */ new Map();
+	const getRunStackedActionCommand = (requestedTarget) => {
+		const targetKey = getVcsActionTargetKey(requestedTarget);
+		const commandKey = targetKey ?? JSON.stringify([
+			"vcs-action-target:unavailable",
+			requestedTarget.environmentId,
+			requestedTarget.cwd
+		]);
+		const existing = runStackedActionCommands.get(commandKey);
+		if (existing !== void 0) return existing;
+		const target = targetKey === null ? null : parseVcsActionTargetKey(targetKey);
+		const stateAtom = targetKey === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(targetKey);
+		const command = createRuntimeCommand(runtime, {
+			label: `vcs-action:run-stacked:${commandKey}`,
+			scheduler: vcsCommandScheduler,
+			concurrency: {
+				mode: "serial",
+				key: () => commandKey
+			},
+			execute: (input, registry) => {
+				if (target === null) return fail(new VcsActionUnavailableError({
+					operation: "run_change_request",
+					environmentId: requestedTarget.environmentId,
+					cwd: requestedTarget.cwd
+				}));
+				const transportActionId = createVcsActionTransportId(target, input.actionId);
+				registry.set(stateAtom, beginVcsActionState({
+					operation: "run_change_request",
+					label: "Running source control action",
+					actionId: input.actionId
+				}));
+				const rpcInput = {
+					actionId: transportActionId,
+					cwd: target.cwd,
+					action: input.action,
+					...input.commitMessage ? { commitMessage: input.commitMessage } : {},
+					...input.featureBranch ? { featureBranch: true } : {},
+					...input.filePaths?.length ? { filePaths: [...input.filePaths] } : {}
+				};
+				return consumeVcsActionProgress(runStreamInEnvironment(target.environmentId, runStream(WS_METHODS.gitRunStackedAction, rpcInput)), {
+					target,
+					transportActionId,
+					actionId: input.actionId,
+					action: input.action,
+					onProgress: (event) => sync(() => {
+						const current = registry.get(stateAtom);
+						if (current.actionId !== input.actionId) return;
+						registry.set(stateAtom, applyVcsActionProgressEvent(current, event));
+						if (input.onProgress !== void 0) try {
+							input.onProgress(event);
+						} catch {}
+					})
+				}).pipe(ensuring(invalidateCachedVcsRefs(registry, target)), tapError((error) => sync(() => {
+					const current = registry.get(stateAtom);
+					if (current.actionId === input.actionId && current.isRunning) registry.set(stateAtom, failVcsActionState("run_change_request", input.actionId, error));
+				})));
+			}
+		});
+		runStackedActionCommands.set(commandKey, command);
+		return command;
+	};
+	const setState = (registry, target, update) => {
+		const key = getVcsActionTargetKey(target);
+		if (key === null) return;
+		const stateAtom = vcsActionStateAtom(key);
+		registry.set(stateAtom, update(registry.get(stateAtom)));
+	};
+	return {
+		stateAtom: getVcsActionStateAtom,
+		runStackedAction: (target) => getRunStackedActionCommand(target),
+		track: async (registry, target, input, action) => {
+			const key = getVcsActionTargetKey(target);
+			if (key === null) return failure(fail$1(new VcsActionUnavailableError({
+				operation: input.operation,
+				environmentId: target.environmentId,
+				cwd: target.cwd
+			})));
+			const stateAtom = vcsActionStateAtom(key);
+			const next = beginVcsActionState(input);
+			registry.set(stateAtom, next);
+			const result = await action();
+			if (registry.get(stateAtom).actionId !== next.actionId) return result;
+			if (isSuccess(result) || hasInterruptsOnly(result.cause)) registry.set(stateAtom, EMPTY_VCS_ACTION_STATE);
+			else if (registry.get(stateAtom).actionId === next.actionId) registry.set(stateAtom, failVcsActionState(input.operation, next.actionId, squash(result.cause)));
+			return result;
+		},
+		resetError: (registry, target, operation) => {
+			setState(registry, target, (current) => !current.isRunning && current.operation === operation ? EMPTY_VCS_ACTION_STATE : current);
+		}
+	};
+}
+//#endregion
+//#region upstream-t3code/packages/client-runtime/src/state/vcs.ts
+const OFFLINE_BRANCH_LIST_LIMIT = 100;
+const VCS_REFS_IDLE_TTL_MS = 3e4;
+const VCS_REFS_RETRY_SCHEDULE = exponential("1 second").pipe(modifyDelay(({ duration }) => succeed(min(duration, seconds(30)))));
+function canUseVcsRefsCache(input) {
+	return input.query === void 0 && input.cursor === void 0 && input.includeMatchingRemoteRefs === void 0 && input.refKind === void 0 && input.limit === OFFLINE_BRANCH_LIST_LIMIT;
+}
+const commitVcsRefsRefresh = fn("CachedVcsRefsState.commitRefresh")(function* (registry, cache, input) {
+	return yield* withVcsRefsPersistenceLock(input.environmentId, gen(function* () {
+		const stateAtom = vcsRefsCacheStateAtom({ environmentId: input.environmentId });
+		const state = registry.get(stateAtom);
+		if (state.revision !== input.expectedRevision) return false;
+		let persistedCacheReadable = state.persistedCacheReadable;
+		if (input.persist) {
+			if (!persistedCacheReadable) persistedCacheReadable = yield* cache.clearVcsRefs(input.environmentId).pipe(as(true), catch_((error) => logWarning("Could not recover invalidated cached Git refs.").pipe(annotateLogs({
+				environmentId: input.environmentId,
+				cwd: input.cwd,
+				...safeErrorLogAttributes(error)
+			}), as(false))));
+			yield* cache.saveVcsRefs(input.environmentId, input.cwd, input.refs).pipe(catch_((error) => logWarning("Could not persist cached Git refs.").pipe(annotateLogs({
+				environmentId: input.environmentId,
+				cwd: input.cwd,
+				...safeErrorLogAttributes(error)
+			}))));
+			if (persistedCacheReadable !== state.persistedCacheReadable) registry.update(stateAtom, (current) => current.revision === input.expectedRevision ? {
+				...current,
+				persistedCacheReadable
+			} : current);
+		}
+		return true;
+	}));
+});
+/**
+* Retains the last unfiltered branch-list response for the new-task picker.
+* Filtered or paginated lists intentionally stay live-only: treating a
+* partial result as a complete offline list would make branch selection
+* misleading.
+*/
+const makeCachedVcsRefsChanges = fn("CachedVcsRefsState.makeChanges")(function* (input, expectedRevision, registry, persistedCacheReadable = true) {
+	const supervisor = yield* EnvironmentSupervisor;
+	const cache = yield* EnvironmentCacheStore;
+	const environmentId = supervisor.target.environmentId;
+	const useCache = canUseVcsRefsCache(input);
+	const cached = useCache && persistedCacheReadable ? yield* cache.loadVcsRefs(environmentId, input.cwd).pipe(catch_((error) => logWarning("Could not load cached Git refs.").pipe(annotateLogs({
+		environmentId,
+		cwd: input.cwd,
+		...safeErrorLogAttributes(error)
+	}), as(none())))) : none();
+	const refresh = fn("CachedVcsRefsState.refresh")(function* () {
+		const refs = yield* request(WS_METHODS.vcsListRefs, input).pipe(provideService(EnvironmentSupervisor, supervisor));
+		const persist = cache.saveVcsRefs(environmentId, input.cwd, refs).pipe(catch_((error) => logWarning("Could not persist cached Git refs.").pipe(annotateLogs({
+			environmentId,
+			cwd: input.cwd,
+			...safeErrorLogAttributes(error)
+		}))));
+		if (expectedRevision === void 0 || registry === void 0) {
+			if (useCache) yield* persist;
+			return some(refs);
+		}
+		return (yield* commitVcsRefsRefresh(registry, cache, {
+			environmentId,
+			cwd: input.cwd,
+			refs,
+			expectedRevision,
+			persist: useCache
+		})) ? some(refs) : none();
+	});
+	return concat(fromEffect(succeed(cached)).pipe(filterMap((refs) => match(refs, {
+		onNone: () => failVoid,
+		onSome: succeed$1
+	}))), concat(fromEffect(get(supervisor.state)), changes(supervisor.state)).pipe(map((connection) => connection.phase === "connected" ? connection.generation : null), changes$1, switchMap((generation) => generation === null ? empty : fromEffect(refresh().pipe(tapError((error) => logWarning("Could not refresh Git refs.").pipe(annotateLogs({
+		environmentId,
+		cwd: input.cwd,
+		...safeErrorLogAttributes(error)
+	}))))).pipe(retry(VCS_REFS_RETRY_SCHEDULE), filterMap((refs) => match(refs, {
+		onNone: () => failVoid,
+		onSome: succeed$1
+	}))))));
+});
+function cachedVcsRefsChanges(environmentId, input, expectedRevision, persistedCacheReadable) {
+	return followStreamInEnvironment(environmentId, unwrap(gen(function* () {
+		const registry = yield* AtomRegistry;
+		return yield* makeCachedVcsRefsChanges(input, expectedRevision, registry, persistedCacheReadable);
+	})));
+}
+function createVcsEnvironmentAtoms(runtime) {
+	const listRefsByEnvironment = family((environmentId) => family((inputKey) => {
+		const input = JSON.parse(inputKey);
+		return runtime.atom((get) => {
+			const state = get(vcsRefsCacheStateAtom({ environmentId }));
+			return cachedVcsRefsChanges(environmentId, input, state.revision, state.persistedCacheReadable);
+		}).pipe(setIdleTTL(VCS_REFS_IDLE_TTL_MS), withLabel(`environment-data:vcs:list-refs:${environmentId}:${inputKey}`));
+	}));
+	const listRefs = (target) => listRefsByEnvironment(target.environmentId)(JSON.stringify(target.input));
+	const invalidateRefs = (target, registry) => invalidateCachedVcsRefs(registry, {
+		environmentId: target.environmentId,
+		cwd: target.input.cwd
+	});
+	return {
+		listRefs,
+		status: createEnvironmentSubscriptionAtomFamily(runtime, {
+			label: "environment-data:vcs:status",
+			subscribe: (input) => subscribe(WS_METHODS.subscribeVcsStatus, input).pipe(mapAccum(() => null, (current, event) => {
+				const next = applyGitStatusStreamEvent(current, event);
+				return [next, [next]];
+			}))
+		}),
+		pull: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:pull",
+			tag: WS_METHODS.vcsPull,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		refreshStatus: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:refresh-status",
+			tag: WS_METHODS.vcsRefreshStatus,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		createWorktree: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:create-worktree",
+			tag: WS_METHODS.vcsCreateWorktree,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		removeWorktree: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:remove-worktree",
+			tag: WS_METHODS.vcsRemoveWorktree,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		createRef: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:create-ref",
+			tag: WS_METHODS.vcsCreateRef,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		switchRef: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:switch-ref",
+			tag: WS_METHODS.vcsSwitchRef,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		}),
+		init: createEnvironmentRpcCommand(runtime, {
+			label: "environment-data:vcs:init",
+			tag: WS_METHODS.vcsInit,
+			scheduler: vcsCommandScheduler,
+			concurrency: vcsCommandConcurrency,
+			onSettled: invalidateRefs
+		})
+	};
+}
+//#endregion
+export { EMPTY_VCS_ACTION_ATOM, EMPTY_VCS_ACTION_STATE, VcsActionExecutionError, VcsActionMissingTerminalEventError, VcsActionOperation, VcsActionRemoteFailureError, VcsActionTargetKeyParseError, VcsActionUnavailableError, applyVcsActionProgressEvent, beginVcsActionState, buildGitActionProgressStages, buildMenuItems, cachedVcsRefsChanges, commitVcsRefsRefresh, consumeVcsActionProgress, createVcsActionManager, createVcsActionTransportId, createVcsEnvironmentAtoms, failVcsActionState, getGitActionDisabledReason, getVcsActionStateAtom, getVcsActionTargetKey, makeCachedVcsRefsChanges, normalizeVcsActionProgressEvent, parseVcsActionTargetKey, requiresDefaultBranchConfirmation, resolveDefaultBranchActionDialogCopy, resolveLiveThreadBranchUpdate, resolveQuickAction, resolveThreadBranchUpdate, vcsActionStateAtom };