codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/services/workspace/workspace-manifest.ts

@@ -0,0 +1,129 @@
+import { basename, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import type { WorkspaceInfo } from "@cline/shared";
+import { processWorkspaceInfo } from "@cline/shared";
+import simpleGit from "simple-git";
+
+export interface WorkspaceInfoDiagnostics {
+	info: WorkspaceInfo;
+	vcsType: "git" | "none";
+	error?: { errorType: string; message: string };
+}
+
+export interface BuiltWorkspaceMetadata {
+	workspaceInfo: WorkspaceInfo;
+	workspaceMetadata: string;
+	durationMs: number;
+	vcsType: "git" | "none";
+	initError?: { errorType: string; message: string };
+}
+
+export function normalizeWorkspacePath(workspacePath: string): string {
+	return resolve(workspacePath);
+}
+
+export async function generateWorkspaceInfo(
+	workspacePath: string,
+): Promise<WorkspaceInfo> {
+	return (await generateWorkspaceInfoWithDiagnostics(workspacePath)).info;
+}
+
+function toWorkspaceInfoError(error: unknown): {
+	errorType: string;
+	message: string;
+} {
+	if (error instanceof Error) {
+		return {
+			errorType: error.name?.trim() || error.constructor.name || "Error",
+			message: error.message,
+		};
+	}
+	return { errorType: "Error", message: String(error) };
+}
+
+export async function generateWorkspaceInfoWithDiagnostics(
+	workspacePath: string,
+): Promise<WorkspaceInfoDiagnostics> {
+	const rootPath = normalizeWorkspacePath(workspacePath);
+	const info: WorkspaceInfo = {
+		rootPath,
+		hint: basename(rootPath),
+	};
+	let firstError: { errorType: string; message: string } | undefined;
+
+	try {
+		const git = simpleGit({ baseDir: rootPath });
+		const isRepo = await git.checkIsRepo();
+		if (!isRepo) {
+			return { info, vcsType: "none" };
+		}
+
+		try {
+			const remotes = await git.getRemotes(true);
+			if (remotes.length > 0) {
+				const associatedRemoteUrls = remotes.map((remote) => {
+					const remoteUrl = remote.refs.fetch || remote.refs.push;
+					return `${remote.name}: ${remoteUrl}`;
+				});
+				info.associatedRemoteUrls = associatedRemoteUrls;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		try {
+			const latestGitCommitHash = (await git.revparse(["HEAD"])).trim();
+			if (latestGitCommitHash.length > 0) {
+				info.latestGitCommitHash = latestGitCommitHash;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		try {
+			const latestGitBranchName = (await git.branch()).current.trim();
+			if (latestGitBranchName.length > 0) {
+				info.latestGitBranchName = latestGitBranchName;
+			}
+		} catch (error) {
+			firstError ??= toWorkspaceInfoError(error);
+		}
+
+		return { info, vcsType: "git", error: firstError };
+	} catch (error) {
+		// Non-git workspaces keep only path + hint.
+		return {
+			info,
+			vcsType: "none",
+			error: toWorkspaceInfoError(error),
+		};
+	}
+}
+
+export async function buildWorkspaceMetadata(cwd: string): Promise<string> {
+	const workspaceInfo = await generateWorkspaceInfo(cwd);
+	return processWorkspaceInfo(workspaceInfo);
+}
+
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export async function buildWorkspaceMetadataWithInfo(
+	cwd: string,
+): Promise<BuiltWorkspaceMetadata> {
+	const startedAt = performance.now();
+	const diagnostics = await generateWorkspaceInfoWithDiagnostics(cwd);
+	const durationMs = performance.now() - startedAt;
+	const workspaceInfo = diagnostics.info;
+	return {
+		workspaceInfo,
+		workspaceMetadata: processWorkspaceInfo(workspaceInfo),
+		durationMs,
+		vcsType: diagnostics.vcsType,
+		initError: diagnostics.error,
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/services/workspace/workspace-telemetry.test.ts

@@ -0,0 +1,166 @@
+import type { ITelemetryService } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import {
+	emitWorkspaceLifecycleTelemetry,
+	resetWorkspaceTelemetryForTests,
+} from "./workspace-telemetry";
+
+interface TelemetryStub {
+	telemetry: ITelemetryService;
+	capture: ReturnType<typeof vi.fn>;
+	captureRequired: ReturnType<typeof vi.fn>;
+}
+
+function createTelemetryStub(): TelemetryStub {
+	const capture = vi.fn();
+	const captureRequired = vi.fn();
+	const telemetry = {
+		capture,
+		captureRequired,
+		setDistinctId: vi.fn(),
+		updateCommonProperties: vi.fn(),
+		identify: vi.fn(),
+	} as unknown as ITelemetryService;
+	return { telemetry, capture, captureRequired };
+}
+
+function findCalls(
+	stub: TelemetryStub,
+	event: string,
+): { event: string; properties?: Record<string, unknown> }[] {
+	return stub.capture.mock.calls
+		.filter(([arg]) => (arg as { event: string }).event === event)
+		.map(
+			([arg]) => arg as { event: string; properties?: Record<string, unknown> },
+		);
+}
+
+describe("emitWorkspaceLifecycleTelemetry", () => {
+	beforeEach(() => {
+		resetWorkspaceTelemetryForTests();
+	});
+
+	afterEach(() => {
+		resetWorkspaceTelemetryForTests();
+	});
+
+	test("emits workspace.initialized once per process per workspace path", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+			rootCount: 1,
+			durationMs: 12,
+		});
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+			rootCount: 1,
+			durationMs: 12,
+		});
+		const initialized = findCalls(stub, "workspace.initialized");
+		expect(initialized).toHaveLength(1);
+	});
+
+	test("emits separate workspace.initialized events for distinct paths", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo-a",
+			vcsType: "git",
+			rootCount: 1,
+		});
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo-b",
+			vcsType: "none",
+			rootCount: 1,
+		});
+		expect(findCalls(stub, "workspace.initialized")).toHaveLength(2);
+	});
+
+	test("emits workspace.init_error only when diagnostics report a failure", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/healthy",
+			vcsType: "git",
+		});
+		expect(findCalls(stub, "workspace.init_error")).toHaveLength(0);
+
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/broken",
+			vcsType: "none",
+			initError: { errorType: "GitProbeError", message: "permission denied" },
+		});
+		const errors = findCalls(stub, "workspace.init_error");
+		expect(errors).toHaveLength(1);
+		expect(errors[0]?.properties?.error_type).toBe("GitProbeError");
+		expect(errors[0]?.properties?.fallback_to_single_root).toBe(true);
+	});
+
+	test("does not emit raw workspace path in event properties", () => {
+		const stub = createTelemetryStub();
+		const rootPath = "/tmp/super-secret-repo-name";
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath,
+			vcsType: "git",
+			rootCount: 1,
+		});
+		expect(stub.captureRequired).not.toHaveBeenCalled();
+		for (const call of stub.capture.mock.calls) {
+			const arg = call[0] as {
+				event: string;
+				properties?: Record<string, unknown>;
+			};
+			expect(JSON.stringify(arg.properties ?? {})).not.toContain(rootPath);
+		}
+	});
+
+	test("emits derived has_git/has_mercurial/is_multi_root flags", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/multi",
+			rootCount: 2,
+			vcsTypes: ["git", "hg"],
+		});
+		const initialized = findCalls(stub, "workspace.initialized");
+		expect(initialized).toHaveLength(1);
+		const props = initialized[0]?.properties as Record<string, unknown>;
+		expect(props.is_multi_root).toBe(true);
+		expect(props.has_git).toBe(true);
+		expect(props.has_mercurial).toBe(true);
+		expect(props.vcs_types).toEqual(["git", "hg"]);
+	});
+
+	test("no-ops when telemetry is undefined", () => {
+		expect(() =>
+			emitWorkspaceLifecycleTelemetry({
+				telemetry: undefined,
+				rootPath: "/tmp/quiet",
+				vcsType: "none",
+			}),
+		).not.toThrow();
+	});
+
+	test("resetWorkspaceTelemetryForTests clears the dedup cache", () => {
+		const stub = createTelemetryStub();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+		});
+		resetWorkspaceTelemetryForTests();
+		emitWorkspaceLifecycleTelemetry({
+			telemetry: stub.telemetry,
+			rootPath: "/tmp/repo",
+			vcsType: "git",
+		});
+		expect(findCalls(stub, "workspace.initialized")).toHaveLength(2);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/services/workspace/workspace-telemetry.ts

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import type { ITelemetryService, WorkspaceInfo } from "@cline/shared";
+import {
+	captureWorkspaceInitError,
+	captureWorkspaceInitialized,
+} from "../telemetry/core-events";
+
+export interface WorkspaceLifecycleTelemetryInput {
+	telemetry?: ITelemetryService;
+	rootPath: string;
+	workspaceInfo?: WorkspaceInfo;
+	rootCount?: number;
+	vcsType?: "git" | "none";
+	vcsTypes?: ReadonlyArray<string>;
+	durationMs?: number;
+	initError?: { errorType: string; message: string };
+	featureFlagEnabled?: boolean;
+	isRemoteWorkspace?: boolean;
+}
+
+const initializedWorkspaceHashes = new Set<string>();
+const initErrorWorkspaceHashes = new Set<string>();
+
+function hashWorkspacePath(rootPath: string): string {
+	return createHash("sha256").update(rootPath).digest("hex");
+}
+
+function normalizeVcsTypes(
+	input: WorkspaceLifecycleTelemetryInput,
+): ReadonlyArray<string> {
+	if (input.vcsTypes && input.vcsTypes.length > 0) {
+		return input.vcsTypes;
+	}
+	return [input.vcsType === "git" ? "git" : "none"];
+}
+
+export function emitWorkspaceLifecycleTelemetry(
+	input: WorkspaceLifecycleTelemetryInput,
+): void {
+	if (!input.telemetry) {
+		return;
+	}
+	const workspaceHash = hashWorkspacePath(input.rootPath);
+	const rootCount = input.rootCount ?? 1;
+	if (!initializedWorkspaceHashes.has(workspaceHash)) {
+		initializedWorkspaceHashes.add(workspaceHash);
+		captureWorkspaceInitialized(input.telemetry, {
+			root_count: rootCount,
+			vcs_types: normalizeVcsTypes(input),
+			init_duration_ms: input.durationMs,
+			feature_flag_enabled: input.featureFlagEnabled ?? true,
+			is_remote_workspace: input.isRemoteWorkspace,
+		});
+	}
+
+	if (input.initError && !initErrorWorkspaceHashes.has(workspaceHash)) {
+		initErrorWorkspaceHashes.add(workspaceHash);
+		const error = new Error(input.initError.message);
+		error.name = input.initError.errorType || "Error";
+		captureWorkspaceInitError(input.telemetry, error, {
+			fallback_to_single_root: true,
+			workspace_count: rootCount,
+		});
+	}
+}
+
+export function resetWorkspaceTelemetryForTests(): void {
+	initializedWorkspaceHashes.clear();
+	initErrorWorkspaceHashes.clear();
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/session/checkpoint-restore.test.ts

@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+	applyCheckpointToWorktree,
+	createCheckpointRestorePlan,
+	createRestoredCheckpointMetadata,
+	trimMessagesBeforeCheckpoint,
+	trimMessagesToCheckpoint,
+} from "./checkpoint-restore";
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+}
+
+function createRepo(cwd: string): void {
+	git(cwd, ["init"]);
+	git(cwd, ["config", "user.name", "Codex Test"]);
+	git(cwd, ["config", "user.email", "codex@example.com"]);
+	writeFileSync(join(cwd, "tracked.txt"), "base\n", "utf8");
+	git(cwd, ["add", "tracked.txt"]);
+	git(cwd, ["commit", "-m", "initial"]);
+}
+
+describe("applyCheckpointToWorktree", () => {
+	let dir = "";
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "checkpoint-restore-"));
+		mkdirSync(dir, { recursive: true });
+		createRepo(dir);
+	});
+
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("validates the checkpoint ref before resetting or cleaning the worktree", async () => {
+		writeFileSync(join(dir, "tracked.txt"), "dirty\n", "utf8");
+		writeFileSync(join(dir, "untracked.txt"), "keep me\n", "utf8");
+
+		await expect(
+			applyCheckpointToWorktree(dir, {
+				ref: "0000000000000000000000000000000000000000",
+				createdAt: Date.now(),
+				runCount: 1,
+				kind: "stash",
+			}),
+		).rejects.toThrow();
+
+		expect(readFileSync(join(dir, "tracked.txt"), "utf8")).toBe("dirty\n");
+		expect(readFileSync(join(dir, "untracked.txt"), "utf8")).toBe("keep me\n");
+	});
+
+	it("carries checkpoint metadata through the restored run", () => {
+		const metadata = createRestoredCheckpointMetadata(
+			{
+				metadata: {
+					checkpoint: {
+						latest: { ref: "cccc", createdAt: 3, runCount: 3 },
+						history: [
+							{ ref: "aaaa", createdAt: 1, runCount: 1 },
+							{ ref: "bbbb", createdAt: 2, runCount: 2 },
+							{ ref: "cccc", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			},
+			2,
+		);
+
+		expect(metadata?.latest.runCount).toBe(2);
+		expect(metadata?.history.map((entry) => entry.runCount)).toEqual([1, 2]);
+	});
+});
+
+describe("checkpoint message trimming", () => {
+	it("can trim either through or before the checkpoint user message", () => {
+		const messages = [
+			{ role: "user" as const, content: "first" },
+			{ role: "assistant" as const, content: "first response" },
+			{ role: "user" as const, content: "second" },
+			{ role: "assistant" as const, content: "second response" },
+		];
+
+		expect(trimMessagesToCheckpoint(messages, 2)).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+			{ role: "user", content: "second" },
+		]);
+		expect(trimMessagesBeforeCheckpoint(messages, 2)).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+		]);
+	});
+
+	it("uses the nearest earlier checkpoint when an identical snapshot was deduplicated", () => {
+		const messages = [
+			{ role: "user" as const, content: "first" },
+			{ role: "assistant" as const, content: "first response" },
+			{ role: "user" as const, content: "second" },
+			{ role: "assistant" as const, content: "second response" },
+			{ role: "user" as const, content: "third" },
+		];
+
+		const plan = createCheckpointRestorePlan({
+			session: {
+				sessionId: "session-1",
+				source: "cli",
+				status: "running",
+				startedAt: "2026-01-01T00:00:00.000Z",
+				updatedAt: "2026-01-01T00:00:00.000Z",
+				interactive: true,
+				provider: "mock",
+				model: "mock",
+				cwd: "/tmp/project",
+				workspaceRoot: "/tmp/project",
+				enableTools: true,
+				enableSpawn: true,
+				enableTeams: true,
+				isSubagent: false,
+				metadata: {
+					checkpoint: {
+						latest: { ref: "cccc", createdAt: 3, runCount: 3 },
+						history: [
+							{ ref: "aaaa", createdAt: 1, runCount: 1 },
+							{ ref: "cccc", createdAt: 3, runCount: 3 },
+						],
+					},
+				},
+			},
+			messages,
+			checkpointRunCount: 2,
+		});
+
+		expect(plan.checkpoint).toMatchObject({ ref: "aaaa", runCount: 1 });
+		expect(plan.messages).toEqual([
+			{ role: "user", content: "first" },
+			{ role: "assistant", content: "first response" },
+			{ role: "user", content: "second" },
+		]);
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/session/checkpoint-restore.ts

@@ -0,0 +1,189 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import type * as LlmsProviders from "@cline/llms";
+import type {
+	CheckpointEntry,
+	CheckpointMetadata,
+} from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+
+const execFile = promisify(execFileCallback);
+
+export interface CheckpointRestorePlan {
+	checkpoint: CheckpointEntry;
+	messages?: LlmsProviders.Message[];
+	cwd: string;
+}
+
+export function readSessionCheckpointHistory(
+	session: Pick<SessionRecord, "metadata"> | undefined,
+): CheckpointEntry[] {
+	const checkpoint =
+		session?.metadata?.checkpoint &&
+		typeof session.metadata.checkpoint === "object" &&
+		!Array.isArray(session.metadata.checkpoint)
+			? (session.metadata.checkpoint as Record<string, unknown>)
+			: undefined;
+	const history = Array.isArray(checkpoint?.history) ? checkpoint.history : [];
+	return history
+		.filter(
+			(entry): entry is Record<string, unknown> =>
+				!!entry && typeof entry === "object" && !Array.isArray(entry),
+		)
+		.flatMap((entry): CheckpointEntry[] => {
+			const ref = String(entry.ref ?? "").trim();
+			const createdAt = Number(entry.createdAt ?? 0);
+			const runCount = Number(entry.runCount ?? 0);
+			if (
+				ref.length === 0 ||
+				!Number.isFinite(createdAt) ||
+				!Number.isInteger(runCount) ||
+				runCount < 1
+			) {
+				return [];
+			}
+			const kind =
+				entry.kind === "stash" || entry.kind === "commit"
+					? entry.kind
+					: undefined;
+			return [{ ref, createdAt, runCount, ...(kind ? { kind } : {}) }];
+		});
+}
+
+export function createRestoredCheckpointMetadata(
+	session: Pick<SessionRecord, "metadata"> | undefined,
+	runCount: number,
+): CheckpointMetadata | undefined {
+	const history = readSessionCheckpointHistory(session).filter(
+		(entry) => entry.runCount <= runCount,
+	);
+	const latest = history.at(-1);
+	return latest ? { latest, history } : undefined;
+}
+
+function findCheckpointForRun(
+	history: readonly CheckpointEntry[],
+	runCount: number,
+): CheckpointEntry | undefined {
+	return history.reduce<CheckpointEntry | undefined>((best, entry) => {
+		if (entry.runCount > runCount) {
+			return best;
+		}
+		if (!best || entry.runCount > best.runCount) {
+			return entry;
+		}
+		return best;
+	}, undefined);
+}
+
+function findCheckpointMessageIndex(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): number {
+	let userRunCount = 0;
+	for (let index = 0; index < messages.length; index += 1) {
+		const message = messages[index];
+		if (message?.role !== "user") {
+			continue;
+		}
+		const metadata =
+			"metadata" in message &&
+			message.metadata &&
+			typeof message.metadata === "object"
+				? (message.metadata as Record<string, unknown>)
+				: undefined;
+		if (metadata?.kind === "recovery_notice") {
+			continue;
+		}
+		userRunCount += 1;
+		if (userRunCount === runCount) {
+			return index;
+		}
+	}
+	throw new Error(`Could not find user message for checkpoint run ${runCount}`);
+}
+
+export function trimMessagesToCheckpoint(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): LlmsProviders.Message[] {
+	const index = findCheckpointMessageIndex(messages, runCount);
+	return messages.slice(0, index + 1);
+}
+
+export function trimMessagesBeforeCheckpoint(
+	messages: LlmsProviders.Message[],
+	runCount: number,
+): LlmsProviders.Message[] {
+	const index = findCheckpointMessageIndex(messages, runCount);
+	return messages.slice(0, index);
+}
+
+export function createCheckpointRestorePlan(input: {
+	session: SessionRecord;
+	messages?: LlmsProviders.Message[];
+	checkpointRunCount: number;
+	cwd?: string;
+	restoreMessages?: boolean;
+}): CheckpointRestorePlan {
+	const runCount = input.checkpointRunCount;
+	if (!Number.isInteger(runCount) || runCount < 1) {
+		throw new Error("checkpointRunCount must be a positive integer");
+	}
+	const checkpoint = findCheckpointForRun(
+		readSessionCheckpointHistory(input.session),
+		runCount,
+	);
+	if (!checkpoint) {
+		throw new Error(
+			`No checkpoint found at or before run ${runCount} in session ${input.session.sessionId}`,
+		);
+	}
+	const cwd = (
+		input.cwd?.trim() ||
+		input.session.cwd ||
+		input.session.workspaceRoot
+	).trim();
+	if (!cwd) {
+		throw new Error("cwd or workspaceRoot is required to restore a checkpoint");
+	}
+	return {
+		checkpoint,
+		cwd,
+		...(input.restoreMessages !== false
+			? {
+					messages: trimMessagesToCheckpoint(input.messages ?? [], runCount),
+				}
+			: {}),
+	};
+}
+
+export async function applyCheckpointToWorktree(
+	cwd: string,
+	checkpoint: CheckpointEntry,
+): Promise<void> {
+	const check = await execFile(
+		"git",
+		["-C", cwd, "rev-parse", "--is-inside-work-tree"],
+		{ windowsHide: true },
+	);
+	if (check.stdout.trim() !== "true") {
+		throw new Error(`${cwd} is not a git repository`);
+	}
+	await execFile(
+		"git",
+		["-C", cwd, "cat-file", "-e", `${checkpoint.ref}^{commit}`],
+		{ windowsHide: true },
+	);
+	await execFile("git", ["-C", cwd, "reset", "--hard"], { windowsHide: true });
+	await execFile("git", ["-C", cwd, "clean", "-fd"], { windowsHide: true });
+	if (checkpoint.kind === "commit") {
+		await execFile("git", ["-C", cwd, "reset", "--hard", checkpoint.ref], {
+			windowsHide: true,
+		});
+		return;
+	}
+	await execFile("git", ["-C", cwd, "stash", "apply", checkpoint.ref], {
+		windowsHide: true,
+	});
+}