@nseng-ai/ccc 0.1.1

package/src/cmux/slot-open-branch.ts

@@ -0,0 +1,241 @@
+import {
+	findLatestBranchContextEvidence,
+	type BranchContextEvidence,
+} from "@nseng-ai/branch-context/api";
+
+import { CCC_WORKSPACE_OPEN_BRANCH_COMMAND_NAME } from "./command-surfaces.ts";
+import { openBranchInCmuxSlot } from "./slot.ts";
+import { createCccSlotClient } from "./slot-checkout.ts";
+import type { SlotClient } from "@nseng-ai/slots/api";
+import type {
+	AutocompleteItem,
+	CommandContext,
+	ExtensionAPI,
+} from "@nseng-ai/capability-kit/cmux/types";
+
+interface BranchCandidate {
+	name: string;
+	scope: "local" | "remote";
+}
+
+type ResolvedBranch =
+	| { inferred: false; branchName: string }
+	| { inferred: true; branchName: string; evidence: BranchContextEvidence }
+	| { error: string };
+
+export interface CccSlotOpenBranchOptions {
+	slotClient?: SlotClient;
+}
+
+export interface HandleCccSlotOpenBranchOptions {
+	pi: Pick<ExtensionAPI, "exec">;
+	args: string;
+	ctx: CommandContext;
+	options?: CccSlotOpenBranchOptions;
+	notifyProgress: (message: string) => void;
+}
+
+const COMMAND_NAME = CCC_WORKSPACE_OPEN_BRANCH_COMMAND_NAME;
+const MAX_COMPLETIONS = 30;
+const BRANCH_FORMAT = "%(refname:short)\t%(refname)";
+
+export async function handleCccSlotOpenBranch(
+	options: HandleCccSlotOpenBranchOptions,
+): Promise<void> {
+	const { pi, args, ctx } = options;
+	const explicitBranch = args.trim();
+	options.notifyProgress(
+		explicitBranch.length > 0
+			? `Opening cmux workspace for ${explicitBranch}…`
+			: "Resolving branch context to open…",
+	);
+	await ctx.waitForIdle();
+
+	const resolved: ResolvedBranch =
+		explicitBranch.length > 0
+			? { branchName: explicitBranch, inferred: false }
+			: await resolveInferredBranchContext(ctx);
+
+	if ("error" in resolved) {
+		ctx.ui.notify(resolved.error, "error");
+		return;
+	}
+
+	if (resolved.inferred) {
+		const confirmed = await confirmInferredBranch(ctx, resolved.evidence);
+		if (!confirmed) {
+			ctx.ui.notify("Cancelled; no cmux workspace was opened.", "info");
+			return;
+		}
+	}
+
+	const branch = resolved.branchName;
+	if (resolved.inferred) {
+		options.notifyProgress(`Opening cmux workspace for ${branch}…`);
+	}
+
+	const launched = await openBranchInCmuxSlot({
+		pi,
+		cwd: ctx.cwd,
+		branchName: branch,
+		slotClient: options.options?.slotClient ?? createCccSlotClient({ cwd: ctx.cwd }),
+		notify: (message, level) => ctx.ui.notify(message, level),
+	});
+	if ("error" in launched) {
+		return;
+	}
+}
+
+async function resolveInferredBranchContext(ctx: {
+	sessionManager?: { getBranch?: () => unknown[] };
+}): Promise<
+	{ inferred: true; branchName: string; evidence: BranchContextEvidence } | { error: string }
+> {
+	const entries = ctx.sessionManager?.getBranch?.() ?? [];
+	const evidence = findLatestBranchContextEvidence(entries);
+	if (!evidence) {
+		return {
+			error: `Usage: /${COMMAND_NAME} <branch>\nNo latest [branch-context-output] branch found in the current session branch.`,
+		};
+	}
+	return { inferred: true, branchName: evidence.branch, evidence };
+}
+
+async function confirmInferredBranch(
+	ctx: {
+		hasUI?: boolean;
+		ui: {
+			confirm?: (title: string, message: string) => Promise<boolean>;
+			notify(message: string, level?: "info" | "warning" | "error"): void;
+		};
+	},
+	evidence: BranchContextEvidence,
+): Promise<boolean> {
+	if (!ctx.hasUI || ctx.ui.confirm === undefined) {
+		ctx.ui.notify(
+			`Cannot infer /${COMMAND_NAME} branch without an interactive confirmation UI.`,
+			"error",
+		);
+		return false;
+	}
+
+	const details = formatInferredBranchConfirmation(evidence);
+	return ctx.ui.confirm("Use branch context?", details);
+}
+
+function formatInferredBranchConfirmation(evidence: BranchContextEvidence): string {
+	return [
+		`Use branch "${evidence.branch}" from the latest [branch-context-output] and open it in a new cmux workspace?`,
+		"",
+		`Key: ${evidence.key}`,
+		`Branch creation: ${evidence.branchCreation}`,
+		`Start point: ${evidence.startPoint}`,
+		`Commit: ${evidence.commit}`,
+		`Source file: ${evidence.sourceFile}`,
+	].join("\n");
+}
+
+export function extractCommandArgumentPrefix(textBeforeCursor: string): string | undefined {
+	const commandPrefix = `/${COMMAND_NAME}`;
+	if (!textBeforeCursor.startsWith(commandPrefix)) {
+		return undefined;
+	}
+
+	const rest = textBeforeCursor.slice(commandPrefix.length);
+	if (!rest.startsWith(" ")) {
+		return undefined;
+	}
+
+	const argumentPrefix = rest.slice(1);
+	return /\s/.test(argumentPrefix.trim()) ? undefined : argumentPrefix;
+}
+
+export async function getBranchCompletions(
+	pi: Pick<ExtensionAPI, "exec">,
+	cwd: string,
+	argumentPrefix: string,
+): Promise<AutocompleteItem[]> {
+	const trimmedPrefix = argumentPrefix.trim();
+	if (/\s/.test(trimmedPrefix)) {
+		return [];
+	}
+
+	const candidates = await listBranchCandidates(pi, cwd);
+	if (!candidates) {
+		return [];
+	}
+
+	return filterBranchCandidates(candidates, trimmedPrefix)
+		.slice(0, MAX_COMPLETIONS)
+		.map((candidate) => ({
+			value: candidate.name,
+			label: candidate.name,
+			description: candidate.scope,
+		}));
+}
+
+async function listBranchCandidates(
+	pi: Pick<ExtensionAPI, "exec">,
+	cwd: string,
+): Promise<BranchCandidate[] | undefined> {
+	const result = await pi.exec(
+		"git",
+		["for-each-ref", `--format=${BRANCH_FORMAT}`, "refs/heads", "refs/remotes"],
+		{ cwd, timeout: 5_000 },
+	);
+	if (result.code !== 0) {
+		return undefined;
+	}
+
+	const seen = new Set<string>();
+	const candidates: BranchCandidate[] = [];
+	for (const line of result.stdout.split("\n")) {
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0) {
+			continue;
+		}
+
+		const [name, ref] = trimmedLine.split("\t");
+		if (!name || !ref || name.endsWith("/HEAD")) {
+			continue;
+		}
+		if (seen.has(name)) {
+			continue;
+		}
+
+		seen.add(name);
+		candidates.push({
+			name,
+			scope: ref.startsWith("refs/heads/") ? "local" : "remote",
+		});
+	}
+
+	return candidates;
+}
+
+function filterBranchCandidates(candidates: BranchCandidate[], prefix: string): BranchCandidate[] {
+	if (prefix.length === 0) {
+		return sortBranchCandidates(candidates);
+	}
+
+	const exactMatches = candidates.filter((candidate) => candidate.name === prefix);
+	if (exactMatches.length > 0) {
+		return sortBranchCandidates(exactMatches);
+	}
+
+	const prefixMatches = candidates.filter((candidate) => candidate.name.startsWith(prefix));
+	if (prefixMatches.length > 0) {
+		return sortBranchCandidates(prefixMatches);
+	}
+
+	return sortBranchCandidates(candidates.filter((candidate) => candidate.name.includes(prefix)));
+}
+
+function sortBranchCandidates(candidates: BranchCandidate[]): BranchCandidate[] {
+	return [...candidates].sort((left, right) => {
+		if (left.scope !== right.scope) {
+			return left.scope === "local" ? -1 : 1;
+		}
+		return left.name.localeCompare(right.name);
+	});
+}

package/src/cmux/slot.ts

@@ -0,0 +1,126 @@
+import { piExecApiToCommandExecApi } from "@nseng-ai/foundation/command";
+import type { SlotCheckoutTarget, SlotClient } from "@nseng-ai/slots/api";
+import { checkoutSlot, formatSlotCheckoutFailureCause } from "./slot-checkout.ts";
+import { RealCmuxGateway, type CmuxGatewayFailure } from "@nseng-ai/capability-kit/cmux/gateway";
+import { getWorktreeDescription } from "./worktree-description.ts";
+import type { ExtensionAPI, NotifyLevel } from "@nseng-ai/capability-kit/cmux/types";
+
+export interface BranchCmuxSlotCheckoutOptions {
+	pi: Pick<ExtensionAPI, "exec">;
+	cwd: string;
+	branchName: string;
+	env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+	slotClient: SlotClient;
+	notify: (message: string, level: NotifyLevel) => void;
+	onStatus?: (message: string) => void;
+}
+
+export interface OpenBranchInCmuxSlotOptions extends BranchCmuxSlotCheckoutOptions {
+	command?: string;
+	description?: string;
+	successMessage?: (target: SlotCheckoutTarget) => string;
+}
+
+export interface OpenCmuxWorkspaceOptions {
+	description: string;
+	command?: string;
+	failureHeading?: string;
+	failureDetails?: readonly string[];
+}
+
+export async function checkoutBranchCmuxSlot(
+	options: BranchCmuxSlotCheckoutOptions,
+): Promise<SlotCheckoutTarget | { error: string }> {
+	const { branchName, notify, onStatus } = options;
+	onStatus?.("checking out branch slot…");
+	const checkout = await checkoutSlot(options.slotClient, { kind: "branch", branchName });
+	if (!checkout.ok) {
+		const cause = formatSlotCheckoutFailureCause(checkout.failure);
+		notify(formatSlotCheckoutFailure(branchName, cause), "error");
+		return { error: cause };
+	}
+
+	return checkout.target;
+}
+
+export async function openBranchInCmuxSlot(
+	options: OpenBranchInCmuxSlotOptions,
+): Promise<SlotCheckoutTarget | { error: string }> {
+	const { pi, command, description, notify, onStatus, successMessage } = options;
+	const target = await checkoutBranchCmuxSlot(options);
+	if ("error" in target) return target;
+	onStatus?.("opening cmux workspace…");
+	const workspaceDescription =
+		description ?? (await getWorktreeDescription(pi, target.worktreePath, target.branchName));
+	const workspaceOptions: OpenCmuxWorkspaceOptions = {
+		description: workspaceDescription,
+		failureHeading: "Checked out the branch slot, but failed to open the cmux workspace.",
+		failureDetails: [`Branch: ${target.branchName}`, `Worktree: ${target.worktreePath}`],
+	};
+	if (command !== undefined) {
+		workspaceOptions.command = command;
+	}
+	const launched = await openCmuxWorkspace(pi, target, workspaceOptions);
+	if ("error" in launched) {
+		notify(launched.error, "error");
+		return launched;
+	}
+
+	notify(
+		successMessage?.(target) ?? `Opened cmux workspace for branch: ${target.branchName}`,
+		"info",
+	);
+	return target;
+}
+
+export async function openCmuxWorkspace(
+	pi: Pick<ExtensionAPI, "exec">,
+	target: SlotCheckoutTarget,
+	options: OpenCmuxWorkspaceOptions,
+): Promise<{ ok: true } | { error: string }> {
+	const cmux = new RealCmuxGateway(piExecApiToCommandExecApi(pi));
+	const result = await cmux.openWorkspace({
+		cwd: target.worktreePath,
+		name: target.branchName,
+		description: options.description,
+		workspaceCwd: target.worktreePath,
+		...(options.command === undefined ? {} : { command: options.command }),
+	});
+	if (result.type === "success") return { ok: true };
+
+	return {
+		error: formatCmuxWorkspaceFailure(result.failure, options),
+	};
+}
+
+export function buildNewWorkspaceArgs(
+	target: SlotCheckoutTarget,
+	options: Pick<OpenCmuxWorkspaceOptions, "description" | "command">,
+): string[] {
+	const args = [
+		"new-workspace",
+		"--name",
+		target.branchName,
+		"--description",
+		options.description,
+		"--cwd",
+		target.worktreePath,
+	];
+	if (options.command !== undefined) {
+		args.push("--command", options.command);
+	}
+	return args;
+}
+
+function formatSlotCheckoutFailure(branchName: string, cause: string): string {
+	return ["Failed to check out branch slot.", `Branch: ${branchName}`, "", cause].join("\n");
+}
+
+function formatCmuxWorkspaceFailure(
+	failure: CmuxGatewayFailure,
+	options: OpenCmuxWorkspaceOptions,
+): string {
+	const heading = options.failureHeading ?? "cmux new-workspace failed.";
+	const lines = [heading, ...(options.failureDetails ?? []), failure.message];
+	return lines.filter((line) => line.length > 0).join("\n");
+}

package/src/cmux/workspace-summary.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+
+import { failure, ok, usageError, type ClinkrExit } from "@nseng-ai/clinkr";
+import type { CommandExecApi } from "@nseng-ai/foundation/command";
+import {
+	RealCmuxGateway,
+	type CmuxGateway,
+	type CmuxGatewayFailure,
+} from "@nseng-ai/capability-kit/cmux/gateway";
+
+export const DEFAULT_CMUX_WORKSPACE_SUMMARY_STATUS_KEY = "pi-summary";
+export const CMUX_WORKSPACE_SUMMARY_COMMAND_TIMEOUT_MS = 30_000;
+
+export const cmuxWorkspaceSummaryRequestSchema = z.strictObject({
+	workspace: z
+		.string()
+		.optional()
+		.describe("Caller cmux workspace id/ref. Defaults to CMUX_WORKSPACE_ID, then CMUX_TAB_ID."),
+	title: z.string().describe("Workspace title."),
+	description: z.string().optional().describe("Workspace description."),
+	statusKey: z
+		.string()
+		.default(DEFAULT_CMUX_WORKSPACE_SUMMARY_STATUS_KEY)
+		.describe("cmux status key to clear."),
+});
+
+const cmuxCommandFailureSchema = z.strictObject({
+	command: z.array(z.string()),
+	exitCode: z.number().int(),
+	stdout: z.string(),
+	stderr: z.string(),
+});
+
+const cmuxWorkspaceSummaryErrorSchema = z.strictObject({
+	code: z.string(),
+	message: z.string(),
+	commandFailure: cmuxCommandFailureSchema.nullable(),
+});
+
+export const cmuxWorkspaceSummaryResultSchema = z.strictObject({
+	success: z.boolean(),
+	workspace: z.string().nullable(),
+	title: z.string(),
+	description: z.string().nullable(),
+	statusKey: z.string(),
+	error: cmuxWorkspaceSummaryErrorSchema.nullable(),
+});
+
+export type CmuxWorkspaceSummaryRequest = z.infer<typeof cmuxWorkspaceSummaryRequestSchema>;
+export type CmuxWorkspaceSummaryResult = z.infer<typeof cmuxWorkspaceSummaryResultSchema>;
+
+type CmuxWorkspaceSummaryFailureCode =
+	| "missing-workspace"
+	| "missing-description"
+	| "rename-workspace-failed"
+	| "set-description-failed"
+	| "clear-status-failed";
+
+interface CmuxWorkspaceSummaryFailure {
+	code: CmuxWorkspaceSummaryFailureCode;
+	message: string;
+	commandFailure?: CmuxGatewayFailure["commandFailure"];
+}
+
+export interface ApplyCmuxWorkspaceSummaryOptions {
+	request: CmuxWorkspaceSummaryRequest;
+	commands: CommandExecApi;
+	cwd: string;
+	env: Record<string, string | undefined>;
+	cmux?: CmuxGateway;
+}
+
+export async function applyCmuxWorkspaceSummaryCommand(
+	options: ApplyCmuxWorkspaceSummaryOptions,
+): Promise<ClinkrExit<CmuxWorkspaceSummaryResult>> {
+	const workspace =
+		nonBlank(options.request.workspace) ??
+		nonBlank(options.env["CMUX_WORKSPACE_ID"]) ??
+		nonBlank(options.env["CMUX_TAB_ID"]);
+	if (workspace === undefined) {
+		return failedExit(options.request, null, {
+			code: "missing-workspace",
+			message:
+				"Not running inside a cmux caller workspace (CMUX_WORKSPACE_ID/CMUX_TAB_ID missing).",
+		});
+	}
+
+	const description = nonBlank(options.request.description);
+	if (description === undefined) {
+		return failedExit(options.request, workspace, {
+			code: "missing-description",
+			message: "Provide --description.",
+		});
+	}
+
+	const cmux = options.cmux ?? new RealCmuxGateway(options.commands);
+	const context = {
+		cwd: options.cwd,
+		env: options.env,
+		timeoutMs: CMUX_WORKSPACE_SUMMARY_COMMAND_TIMEOUT_MS,
+	};
+
+	const renameResult = await cmux.renameWorkspace({
+		...context,
+		workspace,
+		title: options.request.title,
+	});
+	if (renameResult.type === "failed") {
+		return failedExit(
+			options.request,
+			workspace,
+			commandFailure(
+				"rename-workspace-failed",
+				"Failed to rename cmux workspace.",
+				renameResult.failure,
+			),
+		);
+	}
+
+	const descriptionResult = await cmux.setWorkspaceDescription({
+		...context,
+		workspace,
+		description,
+	});
+	if (descriptionResult.type === "failed") {
+		return failedExit(
+			options.request,
+			workspace,
+			commandFailure(
+				"set-description-failed",
+				"Failed to set cmux workspace description.",
+				descriptionResult.failure,
+			),
+		);
+	}
+
+	const clearStatusResult = await cmux.clearStatus({
+		...context,
+		workspace,
+		statusKey: options.request.statusKey,
+	});
+	if (clearStatusResult.type === "failed") {
+		return failedExit(
+			options.request,
+			workspace,
+			commandFailure(
+				"clear-status-failed",
+				"Failed to clear cmux workspace status.",
+				clearStatusResult.failure,
+			),
+		);
+	}
+
+	return ok({
+		success: true,
+		workspace,
+		title: options.request.title,
+		description,
+		statusKey: options.request.statusKey,
+		error: null,
+	});
+}
+
+export function renderCmuxWorkspaceSummaryHuman(data: CmuxWorkspaceSummaryResult): string {
+	if (data.success) return `Applied cmux workspace summary: ${data.title}\n`;
+	return `${data.error?.message ?? "Unknown cmux summary failure."}\n`;
+}
+
+function commandFailure(
+	code: Exclude<CmuxWorkspaceSummaryFailureCode, "missing-workspace" | "missing-description">,
+	baseMessage: string,
+	failure: CmuxGatewayFailure,
+): CmuxWorkspaceSummaryFailure {
+	const commandFailureValue = failure.commandFailure;
+	if (commandFailureValue === undefined) {
+		return { code, message: failure.message };
+	}
+
+	const details = commandFailureValue.stderr.trim() || commandFailureValue.stdout.trim();
+	const message =
+		details.length > 0
+			? `${baseMessage} exit ${commandFailureValue.exitCode}: ${details}`
+			: `${baseMessage} exit ${commandFailureValue.exitCode}.`;
+	return { code, message, commandFailure: commandFailureValue };
+}
+
+function failedExit(
+	request: CmuxWorkspaceSummaryRequest,
+	workspace: string | null,
+	failureResult: CmuxWorkspaceSummaryFailure,
+): ClinkrExit<CmuxWorkspaceSummaryResult> {
+	const result: CmuxWorkspaceSummaryResult = {
+		success: false,
+		workspace,
+		title: request.title,
+		description: null,
+		statusKey: request.statusKey,
+		error: {
+			code: failureResult.code,
+			message: failureResult.message,
+			commandFailure:
+				failureResult.commandFailure === undefined
+					? null
+					: {
+							command: failureResult.commandFailure.command,
+							exitCode: failureResult.commandFailure.exitCode,
+							stdout: failureResult.commandFailure.stdout,
+							stderr: failureResult.commandFailure.stderr,
+						},
+		},
+	};
+	if (failureResult.code === "missing-workspace" || failureResult.code === "missing-description") {
+		return usageError(failureResult.message, result);
+	}
+	return failure(failureResult.code, failureResult.message, result);
+}
+
+function nonBlank(value: string | undefined): string | undefined {
+	if (value === undefined) return undefined;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? undefined : trimmed;
+}

package/src/cmux/worktree-description.ts

@@ -0,0 +1,87 @@
+const GIT_TIMEOUT_MS = 5_000;
+
+interface ExecRuntime {
+	exec(
+		command: string,
+		args: string[],
+		options?: { cwd?: string; timeout?: number },
+	): Promise<{ code: number; stdout: string; stderr: string; killed?: boolean }>;
+}
+
+export async function getWorktreeDescription(
+	pi: ExecRuntime,
+	worktreePath: string,
+	branchName: string,
+): Promise<string> {
+	const repoName = await getGitRepositoryName(pi, worktreePath);
+	return repoName ? `${repoName}/${branchName}` : branchName;
+}
+
+export async function getGitRepositoryName(
+	pi: ExecRuntime,
+	cwd: string,
+): Promise<string | undefined> {
+	const remote = await pi.exec("git", ["remote", "get-url", "origin"], {
+		cwd,
+		timeout: GIT_TIMEOUT_MS,
+	});
+	if (remote.code === 0) {
+		const repoName = repositoryNameFromPath(remote.stdout.trim());
+		if (repoName) {
+			return repoName;
+		}
+	}
+
+	const commonDir = await pi.exec(
+		"git",
+		["rev-parse", "--path-format=absolute", "--git-common-dir"],
+		{
+			cwd,
+			timeout: GIT_TIMEOUT_MS,
+		},
+	);
+	if (commonDir.code !== 0) {
+		return undefined;
+	}
+
+	return repositoryNameFromGitCommonDir(commonDir.stdout.trim());
+}
+
+export function repositoryNameFromGitCommonDir(path: string): string | undefined {
+	const normalized = path.replace(/[\\/]+$/, "");
+	if (normalized.length === 0) {
+		return undefined;
+	}
+
+	const base = basenameForAnyPath(normalized);
+	if (base === ".git") {
+		return basenameForAnyPath(dirnameForAnyPath(normalized)) || undefined;
+	}
+	return stripGitSuffix(base) || undefined;
+}
+
+export function repositoryNameFromPath(path: string): string | undefined {
+	const normalized = path.trim().replace(/[\\/]+$/, "");
+	if (normalized.length === 0) {
+		return undefined;
+	}
+
+	const separatorIndex = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf(":"));
+	return stripGitSuffix(normalized.slice(separatorIndex + 1)) || undefined;
+}
+
+function stripGitSuffix(value: string): string {
+	return value.endsWith(".git") ? value.slice(0, -4) : value;
+}
+
+function basenameForAnyPath(path: string): string {
+	const normalized = path.replace(/[\\/]+$/, "");
+	const parts = normalized.split(/[\\/]/);
+	return parts[parts.length - 1] ?? "";
+}
+
+function dirnameForAnyPath(path: string): string {
+	const normalized = path.replace(/[\\/]+$/, "");
+	const separatorIndex = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
+	return separatorIndex >= 0 ? normalized.slice(0, separatorIndex) : "";
+}

package/src/ns/autobranch/checkpoint.ts

@@ -0,0 +1,35 @@
+import {
+	createCommitWithPreparedMessage,
+	prepareCheckpointMessage,
+	type CommandResult,
+	type PreparedCheckpointMessage,
+} from "@nseng-ai/capability-kit/checkpoint-flow";
+import { createTextGenerator } from "@nseng-ai/ns/kernel/context";
+import type { PendingWorktreeSnapshot } from "@nseng-ai/capability-kit/pending-worktree";
+import { selectCheckpointModelRef } from "@nseng-ai/capability-kit/text-generation";
+
+export type { CommandResult, PreparedCheckpointMessage };
+
+export async function prepareAutobranchCheckpointMessage(
+	snapshot: Pick<PendingWorktreeSnapshot, "status" | "diff">,
+	env: Record<string, string | undefined>,
+): Promise<PreparedCheckpointMessage> {
+	return prepareCheckpointMessage({
+		status: snapshot.status,
+		diff: snapshot.diff,
+		modelRef: selectCheckpointModelRef(env),
+		textGenerator: createTextGenerator(),
+	});
+}
+
+export async function commitAutobranchCheckpointMessage(
+	exec: (command: string, args: string[], cwd: string, timeout: number) => Promise<CommandResult>,
+	cwd: string,
+	message: string,
+): Promise<{ summary: string } | { error: string }> {
+	return createCommitWithPreparedMessage({
+		cwd,
+		message,
+		exec,
+	});
+}