@p4code/cli 0.1.8 → 0.1.10

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$73 = () => {
 const layer$69 = Layer.sync(NetService, make$73);
 //#endregion
 //#region package.json
-var version = "0.1.8";
+var version = "0.1.10";
 //#endregion
 //#region src/config.ts
 /**
@@ -5557,8 +5557,6 @@ const ClientSettingsSchema = Schema$1.Struct({
 	sidebarProjectSortOrder: SidebarProjectSortOrder.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_PROJECT_SORT_ORDER))),
 	sidebarThreadSortOrder: SidebarThreadSortOrder.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_THREAD_SORT_ORDER))),
 	sidebarThreadPreviewCount: SidebarThreadPreviewCount.pipe(Schema$1.withDecodingDefault(Effect.succeed(6))),
-	sidebarV2Enabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
-	sidebarV2ConfiguredByUser: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	timestampFormat: TimestampFormat.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_TIMESTAMP_FORMAT))),
 	wordWrap: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true)))
 });
@@ -5905,8 +5903,6 @@ Schema$1.Struct({
 	sidebarProjectSortOrder: Schema$1.optionalKey(SidebarProjectSortOrder),
 	sidebarThreadSortOrder: Schema$1.optionalKey(SidebarThreadSortOrder),
 	sidebarThreadPreviewCount: Schema$1.optionalKey(SidebarThreadPreviewCount),
-	sidebarV2Enabled: Schema$1.optionalKey(Schema$1.Boolean),
-	sidebarV2ConfiguredByUser: Schema$1.optionalKey(Schema$1.Boolean),
 	timestampFormat: Schema$1.optionalKey(TimestampFormat),
 	wordWrap: Schema$1.optionalKey(Schema$1.Boolean)
 });
@@ -7076,6 +7072,15 @@ const AssigneeField = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_ASSI
 * no remote, where there is nothing stable to key on.
 */
 const RepositoryKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Canonical repository key (normalized git remote, e.g. github.com/owner/repo). Portable across machines, unlike projectId." }));
+/**
+* Manual board position within a column, as a lexicographic fractional key.
+*
+* Compared as a plain string: smaller sorts higher. Keys are minted by the
+* board between the neighbours of a drop, so moving one card writes one row
+* rather than renumbering the column. `null` means the task has never been
+* placed by hand and falls back to the priority/recency order.
+*/
+const OrderKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Manual board position key. Lexicographic: smaller sorts higher in the column. Null means no manual position." }));
 const LabelsField = Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)).pipe(Schema$1.annotateEncoded({ description: "Free-form tags used to group and filter tasks." }));
 const TaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "Id of the task to act on - the UUID or the readable id (e.g. P4-12)." }));
 const Task = Schema$1.Struct({
@@ -7089,6 +7094,15 @@ const Task = Schema$1.Struct({
 	*/
 	readableId: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
 	/**
+	* Manual board position: a lexicographic fractional key, compared as a plain
+	* string, smaller first. Written only when a card is dragged to a position;
+	* `null` means "never placed by hand" and the board falls back to its
+	* priority/recency order. Nullable-with-default for the same version-skew
+	* reason as `readableId`: a row from a store without the migration decodes to
+	* `null` rather than failing the whole board.
+	*/
+	orderKey: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	/**
 	* The project this task belongs to, or `null` for a task that is not scoped
 	* to one. This references the existing workspace project registry rather than
 	* a task-board-private notion of a project.
@@ -7141,7 +7155,13 @@ const TaskCreateInput = Schema$1.Struct({
 */
 const HubTaskCreateInput = Schema$1.Struct({
 	...TaskCreateInput.fields,
-	readableIdPrefix: Schema$1.optional(TrimmedNonEmptyString)
+	readableIdPrefix: Schema$1.optional(TrimmedNonEmptyString),
+	/**
+	* Carried on the hub's create route (but not the public one) so a server
+	* mirroring an already-placed row to the hub does not lose its position.
+	* An agent filing a new task has no business picking a slot.
+	*/
+	orderKey: Schema$1.optional(OrderKeyField)
 });
 /**
 * Every field is optional and an omitted field is left untouched. The nullable
@@ -7158,7 +7178,8 @@ const TaskUpdateInput = Schema$1.Struct({
 	status: Schema$1.optional(StatusField),
 	priority: Schema$1.optional(PriorityField),
 	assignee: Schema$1.optional(Schema$1.NullOr(AssigneeField)),
-	labels: Schema$1.optional(LabelsField)
+	labels: Schema$1.optional(LabelsField),
+	orderKey: Schema$1.optional(Schema$1.NullOr(OrderKeyField))
 });
 /**
 * A task an agent has drafted but has not filed.
@@ -12112,6 +12133,20 @@ var _037_TaskReadableIds_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/038_TaskOrderKeys.ts
+/**
+* Manual board position (`order_key`): a lexicographic fractional key written
+* when a card is dragged to a position, so one move rewrites one row.
+*
+* Existing rows are deliberately not backfilled. A null key means "never placed
+* by hand", and the board's comparator falls back to the old priority/recency
+* order for those - so a board nobody has dragged on looks exactly as it did
+* before this migration.
+*/
+var _038_TaskOrderKeys_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`ALTER TABLE tasks ADD COLUMN order_key TEXT`;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -12317,6 +12352,11 @@ const migrationEntries = [
 		37,
 		"TaskReadableIds",
 		_037_TaskReadableIds_default
+	],
+	[
+		38,
+		"TaskOrderKeys",
+		_038_TaskOrderKeys_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -13950,6 +13990,7 @@ const TASK_COLUMNS = `
   priority,
   assignee,
   labels_json AS "labels",
+  order_key AS "orderKey",
   created_at AS "createdAt",
   updated_at AS "updatedAt"
 `;
@@ -13972,6 +14013,7 @@ const makeTaskRepository = Effect.gen(function* () {
           priority,
           assignee,
           labels_json,
+          order_key,
           created_at,
           updated_at
         )
@@ -13987,6 +14029,7 @@ const makeTaskRepository = Effect.gen(function* () {
           ${row.priority},
           ${row.assignee},
           ${JSON.stringify(row.labels)},
+          ${row.orderKey},
           ${row.createdAt},
           ${row.updatedAt}
         )
@@ -14002,6 +14045,7 @@ const makeTaskRepository = Effect.gen(function* () {
           priority = excluded.priority,
           assignee = excluded.assignee,
           labels_json = excluded.labels_json,
+          order_key = excluded.order_key,
           created_at = excluded.created_at,
           updated_at = excluded.updated_at
       `
@@ -14099,6 +14143,7 @@ const makeTaskRepository = Effect.gen(function* () {
 			...input.priority !== void 0 ? { priority: input.priority } : {},
 			...input.assignee !== void 0 ? { assignee: input.assignee } : {},
 			...input.labels !== void 0 ? { labels: input.labels } : {},
+			...input.orderKey !== void 0 ? { orderKey: input.orderKey } : {},
 			updatedAt
 		};
 		yield* upsertTaskRow(updated);
@@ -14136,6 +14181,7 @@ const makeTaskRepository = Effect.gen(function* () {
 			...input.patch.priority !== void 0 ? { priority: input.patch.priority } : {},
 			...input.patch.assignee !== void 0 ? { assignee: input.patch.assignee } : {},
 			...input.patch.labels !== void 0 ? { labels: input.patch.labels } : {},
+			...input.patch.orderKey !== void 0 ? { orderKey: input.patch.orderKey } : {},
 			updatedAt
 		};
 		yield* upsertTaskRow(updated);
@@ -14268,6 +14314,7 @@ const createTaskRoute = HttpRouter.add("POST", "/tasks", respondToHubFailures(Ef
 		priority: input.priority ?? "none",
 		assignee: input.assignee ?? null,
 		labels: input.labels ?? [],
+		orderKey: input.orderKey ?? null,
 		createdAt: timestamp,
 		updatedAt: timestamp
 	};
@@ -14554,6 +14601,16 @@ var _004_TaskReadableIds_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/hub/Migrations/005_TaskOrderKeys.ts
+/**
+* Manual board position (`order_key`), mirroring the environment server's
+* migration 038: a lexicographic fractional key written when a card is dragged
+* to a position. No backfill - null falls back to priority/recency order.
+*/
+var _005_TaskOrderKeys_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`ALTER TABLE tasks ADD COLUMN order_key TEXT`;
+});
+//#endregion
 //#region src/hub/Migrations.ts
 /**
 * Hub migrations.
@@ -14584,6 +14641,11 @@ const hubMigrationEntries = [
 		4,
 		"TaskReadableIds",
 		_004_TaskReadableIds_default
+	],
+	[
+		5,
+		"TaskOrderKeys",
+		_005_TaskOrderKeys_default
 	]
 ];
 const hubMigrationLoader = Migrator.fromRecord(Object.fromEntries(hubMigrationEntries.map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -28924,222 +28986,868 @@ const staticAndDevRouteLayer = HttpRouter.add("GET", "*", Effect.gen(function* (
 		contentType
 	});
 }));
-//#endregion
-//#region src/checkpointing/Errors.ts
-const CheckpointDiffOperation = Schema$1.Literals(["CheckpointDiffQuery.getTurnDiff", "CheckpointDiffQuery.getFullThreadDiff"]);
-/** The computed result does not satisfy the checkpoint RPC contract. */
-var CheckpointDiffResultInvalidError = class extends Schema$1.TaggedErrorClass()("CheckpointDiffResultInvalidError", {
-	operation: CheckpointDiffOperation,
-	threadId: ThreadId
-}) {
-	get message() {
-		const result = this.operation === "CheckpointDiffQuery.getTurnDiff" ? "turn diff" : "full thread diff";
-		return `Checkpoint invariant violation in ${this.operation}: Computed ${result} result does not satisfy contract schema.`;
-	}
-};
-/** Projection state no longer contains the requested checkpoint thread. */
-var CheckpointThreadNotFoundError = class extends Schema$1.TaggedErrorClass()("CheckpointThreadNotFoundError", {
-	operation: CheckpointDiffOperation,
-	threadId: ThreadId
-}) {
-	get message() {
-		return `Checkpoint invariant violation in ${this.operation}: Thread '${this.threadId}' not found.`;
-	}
-};
-/** The checkpoint thread has no workspace path from which to compute a diff. */
-var CheckpointWorkspacePathMissingError = class extends Schema$1.TaggedErrorClass()("CheckpointWorkspacePathMissingError", {
-	operation: CheckpointDiffOperation,
-	threadId: ThreadId
-}) {
-	get message() {
-		const diff = this.operation === "CheckpointDiffQuery.getTurnDiff" ? "turn diff" : "full thread diff";
-		return `Checkpoint invariant violation in ${this.operation}: Workspace path missing for thread '${this.threadId}' when computing ${diff}.`;
-	}
-};
-/** The requested turn lies beyond the latest available checkpoint. */
-var CheckpointTurnRangeUnavailableError = class extends Schema$1.TaggedErrorClass()("CheckpointTurnRangeUnavailableError", {
-	operation: CheckpointDiffOperation,
-	threadId: ThreadId,
-	requestedTurnCount: NonNegativeInt,
-	availableTurnCount: NonNegativeInt
-}) {
-	get message() {
-		return `Checkpoint unavailable for thread ${this.threadId} turn ${this.requestedTurnCount}: Turn diff range exceeds current turn count: requested ${this.requestedTurnCount}, current ${this.availableTurnCount}.`;
+(() => {
+	try {
+		return process.env.NODE_ENV === "development";
+	} catch {
+		return false;
 	}
-};
-/** Expected checkpoint metadata does not contain the requested Git ref. */
-var CheckpointRefUnavailableError = class extends Schema$1.TaggedErrorClass()("CheckpointRefUnavailableError", {
-	operation: CheckpointDiffOperation,
-	threadId: ThreadId,
-	turnCount: NonNegativeInt,
-	checkpoint: Schema$1.Literals(["from", "to"])
-}) {
-	get message() {
-		return `Checkpoint unavailable for thread ${this.threadId} turn ${this.turnCount}: Checkpoint ref is unavailable for turn ${this.turnCount}.`;
+})();
+const COMMIT_METADATA_SPLIT = /(?=^From [a-f0-9]+ .+$)/m;
+const GIT_DIFF_FILE_BREAK_REGEX = /(?=^diff --git)/gm;
+const FILENAME_HEADER_REGEX = /^(---|\+\+\+)\s+([^\t\r\n]+)/;
+const FILENAME_HEADER_REGEX_GIT = /^(---|\+\+\+)\s+[ab]\/([^\t\r\n]+)/;
+const ALTERNATE_FILE_NAMES_GIT = /^diff --git (?:"a\/(.+?)"|a\/(.+?)) (?:"b\/(.+?)"|b\/(.+?))$/;
+const INDEX_LINE_METADATA = /^index ([0-9a-f]+)\.\.([0-9a-f]+)(?: (\d+))?$/i;
+Object.freeze({
+	fromStart: 0,
+	fromEnd: 0
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/cleanLastNewline.js
+function cleanLastNewline(contents) {
+	let end = contents.length;
+	if (contents.charCodeAt(end - 1) === 10) {
+		end--;
+		if (contents.charCodeAt(end - 1) === 13) end--;
 	}
-};
+	return contents.slice(0, end);
+}
 //#endregion
-//#region src/checkpointing/Utils.ts
-const CHECKPOINT_REFS_PREFIX = "refs/p4/checkpoints";
-function checkpointRefForThreadTurn(threadId, turnCount) {
-	return CheckpointRef.make(`${CHECKPOINT_REFS_PREFIX}/${Encoding.encodeBase64Url(threadId)}/turn/${turnCount}`);
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/detachString.js
+const stringDetachEncoder = new TextEncoder();
+const stringDetachDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+const SURROGATE_CODE_UNIT_PATTERN = /[\uD800-\uDFFF]/;
+const STRING_DETACH_INITIAL_BUFFER_SIZE = 1024;
+let stringDetachBuffer = new Uint8Array(STRING_DETACH_INITIAL_BUFFER_SIZE);
+function releaseStringDetachBuffer() {
+	if (stringDetachBuffer.length !== STRING_DETACH_INITIAL_BUFFER_SIZE) stringDetachBuffer = new Uint8Array(STRING_DETACH_INITIAL_BUFFER_SIZE);
 }
-function resolveThreadWorkspaceCwd(input) {
-	const worktreeCwd = input.thread.worktreePath ?? void 0;
-	if (worktreeCwd) return worktreeCwd;
-	return input.projects.find((project) => project.id === input.thread.projectId)?.workspaceRoot;
+function detachString(value) {
+	if (value.length === 0) return value;
+	if (SURROGATE_CODE_UNIT_PATTERN.test(value)) return JSON.parse(JSON.stringify(value));
+	const requiredByteLength = value.length * 3;
+	if (stringDetachBuffer.length < requiredByteLength) stringDetachBuffer = new Uint8Array(requiredByteLength);
+	const { written } = stringDetachEncoder.encodeInto(value, stringDetachBuffer);
+	return stringDetachDecoder.decode(stringDetachBuffer.subarray(0, written));
 }
 //#endregion
-//#region src/git/remoteRefs.ts
-function parseRemoteNamesInGitOrder(stdout) {
-	const remoteNames = [];
-	for (const line of stdout.split("\n")) {
-		const remoteName = line.trim();
-		if (remoteName.length > 0) remoteNames.push(remoteName);
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/parsePatchFiles.js
+function processPatch(data, cacheKeyPrefix, throwOnError) {
+	try {
+		return _processPatch(data, cacheKeyPrefix, throwOnError);
+	} finally {
+		releaseStringDetachBuffer();
 	}
-	return remoteNames;
-}
-function parseRemoteNames(stdout) {
-	return parseRemoteNamesInGitOrder(stdout).toSorted((a, b) => b.length - a.length);
 }
-function parseRemoteRefWithRemoteNames(ref, remoteNames) {
-	const trimmedRef = ref.trim();
-	if (trimmedRef.length === 0) return null;
-	for (const remoteName of remoteNames) {
-		const remotePrefix = `${remoteName}/`;
-		if (!trimmedRef.startsWith(remotePrefix)) continue;
-		const branchName = trimmedRef.slice(remotePrefix.length).trim();
-		if (branchName.length === 0) return null;
-		return {
-			remoteRef: trimmedRef,
-			remoteName,
-			branchName
-		};
+function _processPatch(data, cacheKeyPrefix, throwOnError = false) {
+	const isGitDiff = isGitDiffPatch(data);
+	const rawFiles = isGitDiff ? splitGitDiffFiles(data) : splitUnifiedDiffFiles(data);
+	let patchMetadata;
+	const files = [];
+	for (const fileOrPatchMetadata of rawFiles) {
+		if (isGitDiff && !GIT_DIFF_FILE_BREAK_REGEX.test(fileOrPatchMetadata)) {
+			if (patchMetadata == null) patchMetadata = detachString(fileOrPatchMetadata);
+			else if (throwOnError) throw Error("parsePatchContent: unknown file blob");
+			else console.error("parsePatchContent: unknown file blob:", fileOrPatchMetadata);
+			continue;
+		} else if (!isGitDiff && !startsWithUnifiedDiffFileHeader(fileOrPatchMetadata)) {
+			if (patchMetadata == null) patchMetadata = detachString(fileOrPatchMetadata);
+			else if (throwOnError) throw Error("parsePatchContent: unknown file blob");
+			else console.error("parsePatchContent: unknown file blob:", fileOrPatchMetadata);
+			continue;
+		}
+		const currentFile = _processFile(fileOrPatchMetadata, {
+			cacheKey: cacheKeyPrefix != null ? `${cacheKeyPrefix}-${files.length}` : void 0,
+			isGitDiff,
+			throwOnError
+		});
+		if (currentFile != null) files.push(currentFile);
 	}
-	return null;
-}
-function extractBranchNameFromRemoteRef(ref, options) {
-	const normalized = ref.trim();
-	if (normalized.length === 0) return "";
-	if (normalized.startsWith("refs/remotes/")) return extractBranchNameFromRemoteRef(normalized.slice(13), options);
-	const parsedRemoteRef = parseRemoteRefWithRemoteNames(normalized, options?.remoteName ? [options.remoteName] : options?.remoteNames ?? []);
-	if (parsedRemoteRef) return parsedRemoteRef.branchName;
-	const firstSlash = normalized.indexOf("/");
-	if (firstSlash === -1) return normalized;
-	return normalized.slice(firstSlash + 1).trim();
-}
-//#endregion
-//#region src/vcs/GitVcsDriverCore.ts
-const DEFAULT_TIMEOUT_MS$5 = 3e4;
-const DEFAULT_MAX_OUTPUT_BYTES$1 = 1e6;
-const OUTPUT_TRUNCATED_MARKER$1 = "\n\n[truncated]";
-const PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES = 49e3;
-const RANGE_COMMIT_SUMMARY_MAX_OUTPUT_BYTES = 19e3;
-const RANGE_DIFF_SUMMARY_MAX_OUTPUT_BYTES = 19e3;
-const RANGE_DIFF_PATCH_MAX_OUTPUT_BYTES = 59e3;
-const REVIEW_DIFF_PATCH_MAX_OUTPUT_BYTES = 12e4;
-const REVIEW_UNTRACKED_DIFF_MAX_OUTPUT_BYTES = 8e4;
-const WORKSPACE_FILES_MAX_OUTPUT_BYTES$1 = 12e4;
-const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
-const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
-const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
-const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
-const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2048;
-const REPOSITORY_PATHS_CACHE_CAPACITY = 2048;
-const REPOSITORY_PATHS_CACHE_TTL = Duration.minutes(10);
-const REPOSITORY_PATHS_REFRESH_COALESCE_TTL = Duration.seconds(5);
-const NON_REPOSITORY_PATHS_CACHE_TTL = Duration.seconds(1);
-const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
-const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
-const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
-const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
-const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
-	GCM_INTERACTIVE: "never",
-	GIT_ASKPASS: "",
-	GIT_TERMINAL_PROMPT: "0",
-	SSH_ASKPASS: "",
-	SSH_ASKPASS_REQUIRE: "never"
-});
-const DEFAULT_BASE_BRANCH_CANDIDATES = ["main", "master"];
-const GIT_LIST_BRANCHES_DEFAULT_LIMIT = 100;
-const NON_REPOSITORY_STATUS_DETAILS = Object.freeze({
-	isRepo: false,
-	hasOriginRemote: false,
-	isDefaultBranch: false,
-	branch: null,
-	upstreamRef: null,
-	hasWorkingTreeChanges: false,
-	workingTree: {
-		files: [],
-		insertions: 0,
-		deletions: 0
-	},
-	hasUpstream: false,
-	aheadCount: 0,
-	behindCount: 0,
-	aheadOfDefaultCount: 0
-});
-const NON_REPOSITORY_REMOTE_STATUS_DETAILS = Object.freeze({
-	isRepo: false,
-	isDefaultBranch: false,
-	branch: null,
-	upstreamRef: null,
-	hasUpstream: false,
-	aheadCount: 0,
-	behindCount: 0,
-	aheadOfDefaultCount: 0
-});
-var StatusRemoteRefreshCacheKey = class extends Data.Class {};
-function statusUpstreamRefreshFailureCooldown(consecutiveFailures) {
-	const exponent = Math.max(0, consecutiveFailures - 1);
-	const cooldownMs = Duration.toMillis(STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN) * Math.pow(2, exponent);
-	return Duration.min(Duration.millis(cooldownMs), STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN);
-}
-var GitRefsSnapshotCacheKey = class extends Data.Class {};
-var GitRefsRefreshCacheKey = class extends Data.Class {};
-function parseBranchAb(value) {
-	const match = value.match(/^\+(\d+)\s+-(\d+)$/);
-	if (!match) return {
-		ahead: 0,
-		behind: 0
-	};
 	return {
-		ahead: Number(match[1] ?? "0"),
-		behind: Number(match[2] ?? "0")
+		patchMetadata,
+		files
 	};
 }
-function parseNumstatEntries(stdout) {
-	const entries = [];
-	for (const line of stdout.split(/\r?\n/g)) {
-		if (line.trim().length === 0) continue;
-		const [addedRaw, deletedRaw, ...pathParts] = line.split("	");
-		const rawPath = pathParts.length > 1 ? (pathParts.at(-1) ?? "").trim() : pathParts.join("	").trim();
-		if (rawPath.length === 0) continue;
-		const added = Number.parseInt(addedRaw ?? "0", 10);
-		const deleted = Number.parseInt(deletedRaw ?? "0", 10);
-		const renameArrowIndex = rawPath.indexOf(" => ");
-		const normalizedPath = renameArrowIndex >= 0 ? rawPath.slice(renameArrowIndex + 4).trim() : rawPath;
-		entries.push({
-			path: normalizedPath.length > 0 ? normalizedPath : rawPath,
-			insertions: Number.isFinite(added) ? added : 0,
-			deletions: Number.isFinite(deleted) ? deleted : 0
-		});
+function _processFile(fileDiffString, { cacheKey, isGitDiff = GIT_DIFF_FILE_BREAK_REGEX.test(fileDiffString), oldFile, newFile, throwOnError = false } = {}) {
+	let lastHunkEnd = 0;
+	const hunks = splitAtLinePrefix(fileDiffString, "@@ ");
+	let currentFile;
+	const isPartial = oldFile == null || newFile == null;
+	let deletionLineIndex = 0;
+	let additionLineIndex = 0;
+	for (const hunk of hunks) {
+		const lines = splitWithNewlines(hunk);
+		const firstLine = lines[0];
+		if (firstLine == null) {
+			if (throwOnError) throw Error("parsePatchContent: invalid hunk");
+			else console.error("parsePatchContent: invalid hunk", hunk);
+			continue;
+		}
+		const fileHeader = parseHunkHeader(firstLine);
+		let additionLines = 0;
+		let deletionLines = 0;
+		if (fileHeader == null || currentFile == null) {
+			if (currentFile != null) {
+				if (throwOnError) throw Error("parsePatchContent: Invalid hunk");
+				else console.error("parsePatchContent: Invalid hunk", hunk);
+				continue;
+			}
+			currentFile = {
+				name: "",
+				type: "change",
+				hunks: [],
+				splitLineCount: 0,
+				unifiedLineCount: 0,
+				isPartial,
+				additionLines: !isPartial && oldFile != null && newFile != null ? splitFileContents(newFile.contents) : [],
+				deletionLines: !isPartial && oldFile != null && newFile != null ? splitFileContents(oldFile.contents) : [],
+				cacheKey: maybeDetachOptionalString(cacheKey)
+			};
+			if (currentFile.additionLines.length === 1 && newFile?.contents === "") currentFile.additionLines.length = 0;
+			if (currentFile.deletionLines.length === 1 && oldFile?.contents === "") currentFile.deletionLines.length = 0;
+			for (const line of lines) {
+				if (line.startsWith("diff --git")) {
+					const filenameMatch$1 = line.trim().match(ALTERNATE_FILE_NAMES_GIT);
+					const prevName = filenameMatch$1?.[1] ?? filenameMatch$1?.[2];
+					const name = filenameMatch$1?.[3] ?? filenameMatch$1?.[4];
+					if (prevName == null || name == null) {
+						if (throwOnError) throw Error("parsePatchContent: invalid git diff header");
+						else console.error("parsePatchContent: invalid git diff header", line);
+						continue;
+					}
+					currentFile.name = detachString(name.trim());
+					if (prevName !== name) currentFile.prevName = detachString(prevName.trim());
+					continue;
+				}
+				const filenameMatch = line.startsWith("---") || line.startsWith("+++") ? line.match(isGitDiff ? FILENAME_HEADER_REGEX_GIT : FILENAME_HEADER_REGEX) : null;
+				if (filenameMatch != null) {
+					const [, type, fileName] = filenameMatch;
+					if (type === "---" && fileName !== "/dev/null") {
+						const detachedFileName = detachString(fileName.trim());
+						currentFile.prevName = detachedFileName;
+						currentFile.name = detachedFileName;
+					} else if (type === "+++" && fileName !== "/dev/null") currentFile.name = detachString(fileName.trim());
+				} else if (isGitDiff) {
+					if (line.startsWith("new mode ")) currentFile.mode = detachString(line.slice(8).trim());
+					if (line.startsWith("old mode ")) currentFile.prevMode = detachString(line.slice(8).trim());
+					if (line.startsWith("new file mode")) {
+						currentFile.type = "new";
+						currentFile.mode = detachString(line.slice(13).trim());
+					}
+					if (line.startsWith("deleted file mode")) {
+						currentFile.type = "deleted";
+						currentFile.mode = detachString(line.slice(17).trim());
+					}
+					if (line.startsWith("similarity index")) if (line.startsWith("similarity index 100%")) currentFile.type = "rename-pure";
+					else currentFile.type = "rename-changed";
+					if (line.startsWith("index ")) {
+						const [, prevObjectId, newObjectId, mode] = line.trim().match(INDEX_LINE_METADATA) ?? [];
+						if (prevObjectId != null) currentFile.prevObjectId = detachString(prevObjectId);
+						if (newObjectId != null) currentFile.newObjectId = detachString(newObjectId);
+						if (mode != null) currentFile.mode = detachString(mode);
+					}
+					if (line.startsWith("rename from ")) currentFile.prevName = detachString(line.slice(12).trim());
+					if (line.startsWith("rename to ")) currentFile.name = detachString(line.slice(10).trim());
+				}
+			}
+			continue;
+		}
+		let currentContent;
+		let lastLineType;
+		while (lines.length > 0 && (lines[lines.length - 1] === "\n" || lines[lines.length - 1] === "\r" || lines[lines.length - 1] === "\r\n" || lines[lines.length - 1] === "")) lines.pop();
+		const { additionStart, deletionStart } = fileHeader;
+		deletionLineIndex = isPartial ? deletionLineIndex : deletionStart - 1;
+		additionLineIndex = isPartial ? additionLineIndex : additionStart - 1;
+		const hunkData = {
+			collapsedBefore: 0,
+			splitLineCount: 0,
+			splitLineStart: 0,
+			unifiedLineCount: 0,
+			unifiedLineStart: 0,
+			additionCount: fileHeader.additionCount,
+			additionStart,
+			additionLines,
+			deletionCount: fileHeader.deletionCount,
+			deletionStart,
+			deletionLines,
+			deletionLineIndex,
+			additionLineIndex,
+			hunkContent: [],
+			hunkContext: maybeDetachOptionalString(fileHeader.hunkContext),
+			hunkSpecs: detachString(firstLine),
+			noEOFCRAdditions: false,
+			noEOFCRDeletions: false
+		};
+		let parsedAdditionLines = 0;
+		let parsedDeletionLines = 0;
+		for (let lineIndex = 1; lineIndex < lines.length; lineIndex++) {
+			const rawLine = lines[lineIndex];
+			if (parsedAdditionLines >= hunkData.additionCount && parsedDeletionLines >= hunkData.deletionCount && !rawLine.startsWith("\\")) {
+				if (throwOnError && isHunkBodyLine(rawLine) && !isFormatPatchVersionSeparator(rawLine)) throw Error("parsePatchContent: hunk has more lines than expected");
+				break;
+			}
+			const firstChar = rawLine[0];
+			if (firstChar !== "+" && firstChar !== "-" && firstChar !== " " && firstChar !== "\\") {
+				if (throwOnError) throw Error("parsePatchContent: invalid hunk line");
+				console.error(`parseLineType: Invalid firstChar: "${firstChar}", full line: "${rawLine}"`);
+				console.error("processFile: invalid rawLine:", rawLine);
+				continue;
+			}
+			const type = parseRawLineType(firstChar);
+			if (type === "addition") {
+				if (throwOnError && parsedAdditionLines >= hunkData.additionCount) throw Error("parsePatchContent: hunk has too many addition lines");
+				const line = getParsedLineContent(rawLine);
+				if (currentContent == null || currentContent.type !== "change") {
+					currentContent = createContentGroup("change", deletionLineIndex, additionLineIndex);
+					hunkData.hunkContent.push(currentContent);
+				}
+				additionLineIndex++;
+				parsedAdditionLines++;
+				if (isPartial) currentFile.additionLines.push(line);
+				currentContent.additions++;
+				additionLines++;
+				lastLineType = "addition";
+			} else if (type === "deletion") {
+				if (throwOnError && parsedDeletionLines >= hunkData.deletionCount) throw Error("parsePatchContent: hunk has too many deletion lines");
+				const line = getParsedLineContent(rawLine);
+				if (currentContent == null || currentContent.type !== "change") {
+					currentContent = createContentGroup("change", deletionLineIndex, additionLineIndex);
+					hunkData.hunkContent.push(currentContent);
+				}
+				deletionLineIndex++;
+				parsedDeletionLines++;
+				if (isPartial) currentFile.deletionLines.push(line);
+				currentContent.deletions++;
+				deletionLines++;
+				lastLineType = "deletion";
+			} else if (type === "context") {
+				if (throwOnError && (parsedDeletionLines >= hunkData.deletionCount || parsedAdditionLines >= hunkData.additionCount)) throw Error("parsePatchContent: hunk has too many context lines");
+				const line = getParsedLineContent(rawLine);
+				if (currentContent == null || currentContent.type !== "context") {
+					currentContent = createContentGroup("context", deletionLineIndex, additionLineIndex);
+					hunkData.hunkContent.push(currentContent);
+				}
+				additionLineIndex++;
+				deletionLineIndex++;
+				parsedAdditionLines++;
+				parsedDeletionLines++;
+				if (isPartial) {
+					currentFile.deletionLines.push(line);
+					currentFile.additionLines.push(line);
+				}
+				currentContent.lines++;
+				lastLineType = "context";
+			} else if (type === "metadata" && currentContent != null) {
+				if (currentContent.type === "context") {
+					hunkData.noEOFCRAdditions = true;
+					hunkData.noEOFCRDeletions = true;
+				} else if (lastLineType === "deletion") hunkData.noEOFCRDeletions = true;
+				else if (lastLineType === "addition") hunkData.noEOFCRAdditions = true;
+				if (isPartial && (lastLineType === "addition" || lastLineType === "context")) {
+					const lastIndex = currentFile.additionLines.length - 1;
+					if (lastIndex >= 0) currentFile.additionLines[lastIndex] = cleanLastNewline(currentFile.additionLines[lastIndex]);
+				}
+				if (isPartial && (lastLineType === "deletion" || lastLineType === "context")) {
+					const lastIndex = currentFile.deletionLines.length - 1;
+					if (lastIndex >= 0) currentFile.deletionLines[lastIndex] = cleanLastNewline(currentFile.deletionLines[lastIndex]);
+				}
+			}
+		}
+		if (throwOnError && (parsedAdditionLines !== hunkData.additionCount || parsedDeletionLines !== hunkData.deletionCount)) throw Error("parsePatchContent: hunk line count mismatch");
+		hunkData.additionLines = additionLines;
+		hunkData.deletionLines = deletionLines;
+		hunkData.collapsedBefore = Math.max(hunkData.additionStart - 1 - lastHunkEnd, 0);
+		currentFile.hunks.push(hunkData);
+		lastHunkEnd = hunkData.additionStart + hunkData.additionCount - 1;
+		for (const content of hunkData.hunkContent) if (content.type === "context") {
+			hunkData.splitLineCount += content.lines;
+			hunkData.unifiedLineCount += content.lines;
+		} else {
+			hunkData.splitLineCount += Math.max(content.additions, content.deletions);
+			hunkData.unifiedLineCount += content.deletions + content.additions;
+		}
+		hunkData.splitLineStart = currentFile.splitLineCount + hunkData.collapsedBefore;
+		hunkData.unifiedLineStart = currentFile.unifiedLineCount + hunkData.collapsedBefore;
+		currentFile.splitLineCount += hunkData.collapsedBefore + hunkData.splitLineCount;
+		currentFile.unifiedLineCount += hunkData.collapsedBefore + hunkData.unifiedLineCount;
 	}
-	return entries;
-}
-function parsePorcelainPath(line) {
-	if (line.startsWith("? ") || line.startsWith("! ")) {
-		const simple = line.slice(2).trim();
-		return simple.length > 0 ? simple : null;
+	if (currentFile == null) return;
+	if (throwOnError && isPartial && !isGitDiff && currentFile.hunks.length === 0) throw Error("parsePatchContent: unified file has no hunks");
+	if (currentFile.hunks.length > 0 && !isPartial && currentFile.additionLines.length > 0 && currentFile.deletionLines.length > 0) {
+		const lastHunk = currentFile.hunks[currentFile.hunks.length - 1];
+		const lastHunkEnd$1 = lastHunk.additionStart + lastHunk.additionCount - 1;
+		const totalFileLines = currentFile.additionLines.length;
+		const collapsedAfter = Math.max(totalFileLines - lastHunkEnd$1, 0);
+		currentFile.splitLineCount += collapsedAfter;
+		currentFile.unifiedLineCount += collapsedAfter;
 	}
-	if (!(line.startsWith("1 ") || line.startsWith("2 ") || line.startsWith("u "))) return null;
-	const tabIndex = line.indexOf("	");
-	if (tabIndex >= 0) {
-		const [filePath] = line.slice(tabIndex + 1).split("	");
-		return filePath?.trim().length ? filePath.trim() : null;
+	if (!isGitDiff) {
+		if (currentFile.prevName != null && currentFile.name !== currentFile.prevName) if (currentFile.hunks.length > 0) currentFile.type = "rename-changed";
+		else currentFile.type = "rename-pure";
+		else if ((oldFile == null || oldFile.contents === "") && newFile != null && newFile.contents !== "") currentFile.type = "new";
+		else if (oldFile != null && oldFile.contents !== "" && (newFile == null || newFile.contents === "")) currentFile.type = "deleted";
 	}
-	const filePath = line.trim().split(/\s+/g).at(-1) ?? "";
-	return filePath.length > 0 ? filePath : null;
+	if (currentFile.type !== "rename-pure" && currentFile.type !== "rename-changed") currentFile.prevName = void 0;
+	return currentFile;
+}
+/**
+* Parses a patch file string into an array of parsed patches.
+*
+* @param data - The raw patch file content (supports multi-commit patches)
+* @param cacheKeyPrefix - Optional prefix for generating cache keys. When provided,
+*   each file in the patch will get a cache key in the format `prefix-patchIndex-fileIndex`.
+*   This enables caching of rendered diff results in the worker pool.
+*/
+function parsePatchFiles(data, cacheKeyPrefix, throwOnError = false) {
+	const patches = [];
+	const rawPatches = hasCommitMetadataBoundary(data) ? data.split(COMMIT_METADATA_SPLIT) : [data];
+	for (const patch of rawPatches) try {
+		patches.push(processPatch(patch, cacheKeyPrefix != null ? `${cacheKeyPrefix}-${patches.length}` : void 0, throwOnError));
+	} catch (error) {
+		if (throwOnError) throw error;
+		else console.error(error);
+	}
+	return patches;
+}
+function hasCommitMetadataBoundary(data) {
+	return data.startsWith("From ") || data.includes("\nFrom ");
+}
+function splitFileContents(contents) {
+	const lines = splitWithNewlines(contents);
+	for (let index = 0; index < lines.length; index++) lines[index] = detachString(lines[index]);
+	return lines;
+}
+function splitWithNewlines(contents) {
+	if (contents.length === 0) return [""];
+	const lines = [];
+	let startIndex = 0;
+	for (;;) {
+		const newlineIndex = contents.indexOf("\n", startIndex);
+		if (newlineIndex === -1) break;
+		lines.push(contents.slice(startIndex, newlineIndex + 1));
+		startIndex = newlineIndex + 1;
+	}
+	if (startIndex < contents.length) lines.push(contents.slice(startIndex));
+	return lines;
+}
+function splitGitDiffFiles(contents) {
+	return splitAtLinePrefix(contents, "diff --git");
+}
+function splitUnifiedDiffFiles(contents) {
+	if (contents.length === 0) return [""];
+	const parts = [];
+	let partStartIndex = 0;
+	let lineStartIndex = 0;
+	let remainingDeletionLines = 0;
+	let remainingAdditionLines = 0;
+	let hasOpenedUnifiedFile = false;
+	while (lineStartIndex < contents.length) {
+		const nextLineStartIndex = getNextLineStartIndex(contents, lineStartIndex);
+		if (remainingDeletionLines <= 0 && remainingAdditionLines <= 0) {
+			if (isUnifiedDiffFileHeaderAt(contents, lineStartIndex)) {
+				if (lineStartIndex > partStartIndex) parts.push(contents.slice(partStartIndex, lineStartIndex));
+				partStartIndex = lineStartIndex;
+				hasOpenedUnifiedFile = true;
+				lineStartIndex = getNextLineStartIndex(contents, nextLineStartIndex);
+				continue;
+			}
+			if (hasOpenedUnifiedFile && contents.startsWith("@@ -", lineStartIndex)) {
+				const fileHeader = parseHunkHeader(contents.slice(lineStartIndex, nextLineStartIndex));
+				if (fileHeader != null) {
+					remainingDeletionLines = fileHeader.deletionCount;
+					remainingAdditionLines = fileHeader.additionCount;
+				}
+			}
+			lineStartIndex = nextLineStartIndex;
+			continue;
+		}
+		const firstChar = contents[lineStartIndex];
+		if (firstChar === "\\") {
+			lineStartIndex = nextLineStartIndex;
+			continue;
+		}
+		if (firstChar === " ") {
+			remainingDeletionLines = Math.max(remainingDeletionLines - 1, 0);
+			remainingAdditionLines = Math.max(remainingAdditionLines - 1, 0);
+		} else if (firstChar === "-") remainingDeletionLines = Math.max(remainingDeletionLines - 1, 0);
+		else if (firstChar === "+") remainingAdditionLines = Math.max(remainingAdditionLines - 1, 0);
+		lineStartIndex = nextLineStartIndex;
+	}
+	parts.push(contents.slice(partStartIndex));
+	return parts;
+}
+function startsWithUnifiedDiffFileHeader(contents) {
+	return isUnifiedDiffFileHeaderAt(contents, 0);
+}
+function isUnifiedDiffFileHeaderAt(contents, lineStartIndex) {
+	const nextLineStartIndex = getNextLineStartIndex(contents, lineStartIndex);
+	return isUnifiedDiffHeaderLineAt(contents, lineStartIndex, "---") && isUnifiedDiffHeaderLineAt(contents, nextLineStartIndex, "+++");
+}
+function isUnifiedDiffHeaderLineAt(contents, lineStartIndex, prefix) {
+	if (!contents.startsWith(prefix, lineStartIndex)) return false;
+	const separator = contents[lineStartIndex + prefix.length];
+	if (separator !== " " && separator !== "	") return false;
+	for (let index = lineStartIndex + prefix.length + 1; index < contents.length; index++) {
+		const char = contents[index];
+		if (char === "\n" || char === "\r") break;
+		if (char !== " " && char !== "	") return true;
+	}
+	return false;
+}
+function getNextLineStartIndex(contents, lineStartIndex) {
+	const newlineIndex = contents.indexOf("\n", lineStartIndex);
+	return newlineIndex === -1 ? contents.length : newlineIndex + 1;
+}
+function isHunkBodyLine(line) {
+	const firstChar = line[0];
+	return firstChar === "+" || firstChar === "-" || firstChar === " ";
+}
+function isFormatPatchVersionSeparator(line) {
+	if (!line.startsWith("--")) return false;
+	for (let index = 2; index < line.length; index++) {
+		const char = line[index];
+		if (char !== " " && char !== "	" && char !== "\n" && char !== "\r") return false;
+	}
+	return true;
+}
+function parseHunkHeader(line) {
+	if (!line.startsWith("@@ -")) return;
+	let index = 4;
+	const deletionStartResult = readPositiveInteger(line, index);
+	if (deletionStartResult == null) return;
+	const deletionStart = deletionStartResult.value;
+	index = deletionStartResult.endIndex;
+	let deletionCount = 1;
+	if (line[index] === ",") {
+		const deletionCountResult = readPositiveInteger(line, index + 1);
+		if (deletionCountResult == null) return;
+		deletionCount = deletionCountResult.value;
+		index = deletionCountResult.endIndex;
+	}
+	if (line[index] !== " " || line[index + 1] !== "+") return;
+	index += 2;
+	const additionStartResult = readPositiveInteger(line, index);
+	if (additionStartResult == null) return;
+	const additionStart = additionStartResult.value;
+	index = additionStartResult.endIndex;
+	let additionCount = 1;
+	if (line[index] === ",") {
+		const additionCountResult = readPositiveInteger(line, index + 1);
+		if (additionCountResult == null) return;
+		additionCount = additionCountResult.value;
+		index = additionCountResult.endIndex;
+	}
+	if (line[index] !== " " || line[index + 1] !== "@" || line[index + 2] !== "@") return;
+	let hunkContext;
+	const contextStartIndex = index + 3;
+	if (line[contextStartIndex] === " ") hunkContext = trimLineEnd(line.slice(contextStartIndex + 1));
+	return {
+		additionCount,
+		additionStart,
+		deletionCount,
+		deletionStart,
+		hunkContext
+	};
+}
+function readPositiveInteger(value, startIndex) {
+	let index = startIndex;
+	let parsedValue = 0;
+	for (; index < value.length; index++) {
+		const digit = value.charCodeAt(index) - 48;
+		if (digit < 0 || digit > 9) break;
+		parsedValue = parsedValue * 10 + digit;
+	}
+	if (index === startIndex) return;
+	return {
+		value: parsedValue,
+		endIndex: index
+	};
+}
+function trimLineEnd(value) {
+	if (value.endsWith("\r\n")) return value.slice(0, -2);
+	if (value.endsWith("\n")) return value.slice(0, -1);
+	return value;
+}
+function isGitDiffPatch(data) {
+	return data.startsWith("diff --git") || data.includes("\ndiff --git");
+}
+function splitAtLinePrefix(contents, prefix) {
+	if (contents.length === 0) return [""];
+	const newlinePrefix = `\n${prefix}`;
+	const firstBoundaryIndex = contents.startsWith(prefix) ? 0 : findLinePrefixIndex(contents, newlinePrefix, 0);
+	if (firstBoundaryIndex === -1) return [contents];
+	const parts = [];
+	if (firstBoundaryIndex > 0) parts.push(contents.slice(0, firstBoundaryIndex));
+	let startIndex = firstBoundaryIndex;
+	for (;;) {
+		const nextBoundaryIndex = findLinePrefixIndex(contents, newlinePrefix, startIndex + 1);
+		if (nextBoundaryIndex === -1) break;
+		parts.push(contents.slice(startIndex, nextBoundaryIndex));
+		startIndex = nextBoundaryIndex;
+	}
+	parts.push(contents.slice(startIndex));
+	return parts;
+}
+function findLinePrefixIndex(contents, newlinePrefix, fromIndex) {
+	const index = contents.indexOf(newlinePrefix, fromIndex);
+	return index === -1 ? -1 : index + 1;
+}
+function maybeDetachOptionalString(value) {
+	return value == null ? value : detachString(value);
+}
+function parseRawLineType(firstChar) {
+	return firstChar === " " ? "context" : firstChar === "\\" ? "metadata" : firstChar === "+" ? "addition" : "deletion";
+}
+function getParsedLineContent(rawLine) {
+	const processedLine = rawLine.slice(1);
+	return detachString(processedLine === "" ? "\n" : processedLine);
+}
+function createContentGroup(type, deletionLineIndex, additionLineIndex) {
+	if (type === "change") return {
+		type: "change",
+		additions: 0,
+		deletions: 0,
+		additionLineIndex,
+		deletionLineIndex
+	};
+	return {
+		type: "context",
+		lines: 0,
+		additionLineIndex,
+		deletionLineIndex
+	};
+}
+//#endregion
+//#region src/checkpointing/ThreadChangedFiles.ts
+/**
+* Per-thread changed-file attribution for checkpoint diffs.
+*
+* A checkpoint snapshots the whole working tree (`git add -A`), so on a shared
+* worktree the diff between two of a thread's checkpoints also contains every
+* edit other threads made in the window. The thread's own tool activities are
+* per-thread by construction, and the inline changed-files summary the clients
+* derive from them is already the surface users trust. These helpers extract
+* that same path list on the server and cut a checkpoint diff down to it.
+*
+* `collectActivityChangedFilePaths` must stay in lockstep with
+* `collectChangedFiles` in `apps/web/src/session-logic.ts` (and the mobile
+* copy in `threadActivity.ts`): same field names, same nested keys, same depth
+* bound. The one deliberate difference is dropping the cap of 12 paths - that
+* cap exists for display, and a filter that stopped collecting would silently
+* drop real work from the diff.
+*
+* @module ThreadChangedFiles
+*/
+const CHANGED_FILE_FIELDS = [
+	"path",
+	"filePath",
+	"relativePath",
+	"filename",
+	"newPath",
+	"oldPath"
+];
+const NESTED_PAYLOAD_KEYS = [
+	"item",
+	"result",
+	"input",
+	"data",
+	"changes",
+	"files",
+	"edits",
+	"patch",
+	"patches",
+	"operations"
+];
+const MAX_COLLECT_DEPTH = 4;
+function asRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function pushChangedFilePath(target, value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (normalized.length === 0) return;
+	target.add(normalized);
+}
+function collectChangedFilePaths(value, target, depth) {
+	if (depth > MAX_COLLECT_DEPTH) return;
+	if (Array.isArray(value)) {
+		for (const entry of value) collectChangedFilePaths(entry, target, depth + 1);
+		return;
+	}
+	const record = asRecord$3(value);
+	if (!record) return;
+	for (const field of CHANGED_FILE_FIELDS) pushChangedFilePath(target, record[field]);
+	for (const nestedKey of NESTED_PAYLOAD_KEYS) if (nestedKey in record) collectChangedFilePaths(record[nestedKey], target, depth + 1);
+}
+/**
+* Extract the file paths a single activity payload names, exactly as the
+* clients do for the inline changed-files summary.
+*/
+function collectActivityChangedFilePaths(payload) {
+	const target = /* @__PURE__ */ new Set();
+	collectChangedFilePaths(asRecord$3(asRecord$3(payload)?.data), target, 0);
+	return target;
+}
+/**
+* Normalize activity-named paths to the workspace-relative form git patches
+* use. Adapters report paths as the tool received them, which may be absolute;
+* a path outside the workspace cannot appear in the checkpoint diff and is
+* dropped rather than mismatched.
+*/
+function normalizeChangedFilePaths(changedPaths, workspaceCwd) {
+	const workspacePrefix = workspaceCwd.endsWith("/") ? workspaceCwd : `${workspaceCwd}/`;
+	const normalized = /* @__PURE__ */ new Set();
+	for (const changedPath of changedPaths) {
+		let candidate = changedPath;
+		if (candidate.startsWith(workspacePrefix)) candidate = candidate.slice(workspacePrefix.length);
+		else if (candidate.startsWith("/")) continue;
+		else if (candidate.startsWith("./")) candidate = candidate.slice(2);
+		if (candidate.length > 0) normalized.add(candidate);
+	}
+	return normalized;
+}
+const DIFF_FILE_HEADER = /^diff --git /gm;
+function splitUnifiedDiffBlocks(diff) {
+	const starts = [];
+	for (const match of diff.matchAll(DIFF_FILE_HEADER)) starts.push(match.index);
+	return starts.map((start, index) => diff.slice(start, starts[index + 1]));
+}
+function blockNamesPath(block, allowedPaths) {
+	try {
+		return parsePatchFiles(block).some((patch) => patch.files.some((file) => allowedPaths.has(file.name) || file.prevName !== void 0 && allowedPaths.has(file.prevName)));
+	} catch {
+		return true;
+	}
+}
+/**
+* Cut a unified diff down to the files a thread's own activities name.
+*
+* `changedPaths` is the raw activity path list; normalization against
+* `workspaceCwd` happens here. The caller decides what an empty path list
+* means - this function treats it literally and returns an empty diff.
+*/
+function filterUnifiedDiffToChangedFiles(diff, changedPaths, workspaceCwd) {
+	if (diff.length === 0) return diff;
+	const allowedPaths = normalizeChangedFilePaths(changedPaths, workspaceCwd);
+	return splitUnifiedDiffBlocks(diff).filter((block) => blockNamesPath(block, allowedPaths)).join("");
+}
+//#endregion
+//#region src/checkpointing/Errors.ts
+const CheckpointDiffOperation = Schema$1.Literals(["CheckpointDiffQuery.getTurnDiff", "CheckpointDiffQuery.getFullThreadDiff"]);
+/** The computed result does not satisfy the checkpoint RPC contract. */
+var CheckpointDiffResultInvalidError = class extends Schema$1.TaggedErrorClass()("CheckpointDiffResultInvalidError", {
+	operation: CheckpointDiffOperation,
+	threadId: ThreadId
+}) {
+	get message() {
+		const result = this.operation === "CheckpointDiffQuery.getTurnDiff" ? "turn diff" : "full thread diff";
+		return `Checkpoint invariant violation in ${this.operation}: Computed ${result} result does not satisfy contract schema.`;
+	}
+};
+/** Projection state no longer contains the requested checkpoint thread. */
+var CheckpointThreadNotFoundError = class extends Schema$1.TaggedErrorClass()("CheckpointThreadNotFoundError", {
+	operation: CheckpointDiffOperation,
+	threadId: ThreadId
+}) {
+	get message() {
+		return `Checkpoint invariant violation in ${this.operation}: Thread '${this.threadId}' not found.`;
+	}
+};
+/** The checkpoint thread has no workspace path from which to compute a diff. */
+var CheckpointWorkspacePathMissingError = class extends Schema$1.TaggedErrorClass()("CheckpointWorkspacePathMissingError", {
+	operation: CheckpointDiffOperation,
+	threadId: ThreadId
+}) {
+	get message() {
+		const diff = this.operation === "CheckpointDiffQuery.getTurnDiff" ? "turn diff" : "full thread diff";
+		return `Checkpoint invariant violation in ${this.operation}: Workspace path missing for thread '${this.threadId}' when computing ${diff}.`;
+	}
+};
+/** The requested turn lies beyond the latest available checkpoint. */
+var CheckpointTurnRangeUnavailableError = class extends Schema$1.TaggedErrorClass()("CheckpointTurnRangeUnavailableError", {
+	operation: CheckpointDiffOperation,
+	threadId: ThreadId,
+	requestedTurnCount: NonNegativeInt,
+	availableTurnCount: NonNegativeInt
+}) {
+	get message() {
+		return `Checkpoint unavailable for thread ${this.threadId} turn ${this.requestedTurnCount}: Turn diff range exceeds current turn count: requested ${this.requestedTurnCount}, current ${this.availableTurnCount}.`;
+	}
+};
+/** Expected checkpoint metadata does not contain the requested Git ref. */
+var CheckpointRefUnavailableError = class extends Schema$1.TaggedErrorClass()("CheckpointRefUnavailableError", {
+	operation: CheckpointDiffOperation,
+	threadId: ThreadId,
+	turnCount: NonNegativeInt,
+	checkpoint: Schema$1.Literals(["from", "to"])
+}) {
+	get message() {
+		return `Checkpoint unavailable for thread ${this.threadId} turn ${this.turnCount}: Checkpoint ref is unavailable for turn ${this.turnCount}.`;
+	}
+};
+//#endregion
+//#region src/checkpointing/Utils.ts
+const CHECKPOINT_REFS_PREFIX = "refs/p4/checkpoints";
+function checkpointRefForThreadTurn(threadId, turnCount) {
+	return CheckpointRef.make(`${CHECKPOINT_REFS_PREFIX}/${Encoding.encodeBase64Url(threadId)}/turn/${turnCount}`);
+}
+function resolveThreadWorkspaceCwd(input) {
+	const worktreeCwd = input.thread.worktreePath ?? void 0;
+	if (worktreeCwd) return worktreeCwd;
+	return input.projects.find((project) => project.id === input.thread.projectId)?.workspaceRoot;
+}
+//#endregion
+//#region src/git/remoteRefs.ts
+function parseRemoteNamesInGitOrder(stdout) {
+	const remoteNames = [];
+	for (const line of stdout.split("\n")) {
+		const remoteName = line.trim();
+		if (remoteName.length > 0) remoteNames.push(remoteName);
+	}
+	return remoteNames;
+}
+function parseRemoteNames(stdout) {
+	return parseRemoteNamesInGitOrder(stdout).toSorted((a, b) => b.length - a.length);
+}
+function parseRemoteRefWithRemoteNames(ref, remoteNames) {
+	const trimmedRef = ref.trim();
+	if (trimmedRef.length === 0) return null;
+	for (const remoteName of remoteNames) {
+		const remotePrefix = `${remoteName}/`;
+		if (!trimmedRef.startsWith(remotePrefix)) continue;
+		const branchName = trimmedRef.slice(remotePrefix.length).trim();
+		if (branchName.length === 0) return null;
+		return {
+			remoteRef: trimmedRef,
+			remoteName,
+			branchName
+		};
+	}
+	return null;
+}
+function extractBranchNameFromRemoteRef(ref, options) {
+	const normalized = ref.trim();
+	if (normalized.length === 0) return "";
+	if (normalized.startsWith("refs/remotes/")) return extractBranchNameFromRemoteRef(normalized.slice(13), options);
+	const parsedRemoteRef = parseRemoteRefWithRemoteNames(normalized, options?.remoteName ? [options.remoteName] : options?.remoteNames ?? []);
+	if (parsedRemoteRef) return parsedRemoteRef.branchName;
+	const firstSlash = normalized.indexOf("/");
+	if (firstSlash === -1) return normalized;
+	return normalized.slice(firstSlash + 1).trim();
+}
+//#endregion
+//#region src/vcs/GitVcsDriverCore.ts
+const DEFAULT_TIMEOUT_MS$5 = 3e4;
+const DEFAULT_MAX_OUTPUT_BYTES$1 = 1e6;
+const OUTPUT_TRUNCATED_MARKER$1 = "\n\n[truncated]";
+const PREPARED_COMMIT_PATCH_MAX_OUTPUT_BYTES = 49e3;
+const RANGE_COMMIT_SUMMARY_MAX_OUTPUT_BYTES = 19e3;
+const RANGE_DIFF_SUMMARY_MAX_OUTPUT_BYTES = 19e3;
+const RANGE_DIFF_PATCH_MAX_OUTPUT_BYTES = 59e3;
+const REVIEW_DIFF_PATCH_MAX_OUTPUT_BYTES = 12e4;
+const REVIEW_UNTRACKED_DIFF_MAX_OUTPUT_BYTES = 8e4;
+const WORKSPACE_FILES_MAX_OUTPUT_BYTES$1 = 12e4;
+const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
+const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
+const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
+const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
+const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2048;
+const REPOSITORY_PATHS_CACHE_CAPACITY = 2048;
+const REPOSITORY_PATHS_CACHE_TTL = Duration.minutes(10);
+const REPOSITORY_PATHS_REFRESH_COALESCE_TTL = Duration.seconds(5);
+const NON_REPOSITORY_PATHS_CACHE_TTL = Duration.seconds(1);
+const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
+const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
+const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
+const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
+const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
+	GCM_INTERACTIVE: "never",
+	GIT_ASKPASS: "",
+	GIT_TERMINAL_PROMPT: "0",
+	SSH_ASKPASS: "",
+	SSH_ASKPASS_REQUIRE: "never"
+});
+const DEFAULT_BASE_BRANCH_CANDIDATES = ["main", "master"];
+const GIT_LIST_BRANCHES_DEFAULT_LIMIT = 100;
+const NON_REPOSITORY_STATUS_DETAILS = Object.freeze({
+	isRepo: false,
+	hasOriginRemote: false,
+	isDefaultBranch: false,
+	branch: null,
+	upstreamRef: null,
+	hasWorkingTreeChanges: false,
+	workingTree: {
+		files: [],
+		insertions: 0,
+		deletions: 0
+	},
+	hasUpstream: false,
+	aheadCount: 0,
+	behindCount: 0,
+	aheadOfDefaultCount: 0
+});
+const NON_REPOSITORY_REMOTE_STATUS_DETAILS = Object.freeze({
+	isRepo: false,
+	isDefaultBranch: false,
+	branch: null,
+	upstreamRef: null,
+	hasUpstream: false,
+	aheadCount: 0,
+	behindCount: 0,
+	aheadOfDefaultCount: 0
+});
+var StatusRemoteRefreshCacheKey = class extends Data.Class {};
+function statusUpstreamRefreshFailureCooldown(consecutiveFailures) {
+	const exponent = Math.max(0, consecutiveFailures - 1);
+	const cooldownMs = Duration.toMillis(STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN) * Math.pow(2, exponent);
+	return Duration.min(Duration.millis(cooldownMs), STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN);
+}
+var GitRefsSnapshotCacheKey = class extends Data.Class {};
+var GitRefsRefreshCacheKey = class extends Data.Class {};
+function parseBranchAb(value) {
+	const match = value.match(/^\+(\d+)\s+-(\d+)$/);
+	if (!match) return {
+		ahead: 0,
+		behind: 0
+	};
+	return {
+		ahead: Number(match[1] ?? "0"),
+		behind: Number(match[2] ?? "0")
+	};
+}
+function parseNumstatEntries(stdout) {
+	const entries = [];
+	for (const line of stdout.split(/\r?\n/g)) {
+		if (line.trim().length === 0) continue;
+		const [addedRaw, deletedRaw, ...pathParts] = line.split("	");
+		const rawPath = pathParts.length > 1 ? (pathParts.at(-1) ?? "").trim() : pathParts.join("	").trim();
+		if (rawPath.length === 0) continue;
+		const added = Number.parseInt(addedRaw ?? "0", 10);
+		const deleted = Number.parseInt(deletedRaw ?? "0", 10);
+		const renameArrowIndex = rawPath.indexOf(" => ");
+		const normalizedPath = renameArrowIndex >= 0 ? rawPath.slice(renameArrowIndex + 4).trim() : rawPath;
+		entries.push({
+			path: normalizedPath.length > 0 ? normalizedPath : rawPath,
+			insertions: Number.isFinite(added) ? added : 0,
+			deletions: Number.isFinite(deleted) ? deleted : 0
+		});
+	}
+	return entries;
+}
+function parsePorcelainPath(line) {
+	if (line.startsWith("? ") || line.startsWith("! ")) {
+		const simple = line.slice(2).trim();
+		return simple.length > 0 ? simple : null;
+	}
+	if (!(line.startsWith("1 ") || line.startsWith("2 ") || line.startsWith("u "))) return null;
+	const tabIndex = line.indexOf("	");
+	if (tabIndex >= 0) {
+		const [filePath] = line.slice(tabIndex + 1).split("	");
+		return filePath?.trim().length ? filePath.trim() : null;
+	}
+	const filePath = line.trim().split(/\s+/g).at(-1) ?? "";
+	return filePath.length > 0 ? filePath : null;
 }
 function filterBranchesForListQuery(refs, query) {
 	if (!query) return refs;
@@ -31530,6 +32238,32 @@ function buildTurnDiffResult(input, diff) {
 const make$39 = Effect.gen(function* () {
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
 	const checkpointStore = yield* CheckpointStore;
+	const threadActivities = yield* ProjectionThreadActivityRepository;
+	/**
+	* The file paths this thread's own tool activities name, optionally limited
+	* to a set of turns. This is the attribution a checkpoint cannot provide: a
+	* checkpoint snapshots the whole tree, so on a shared worktree its diff also
+	* contains other threads' edits, while activities are per-thread by
+	* construction.
+	*/
+	const collectThreadChangedFilePaths = Effect.fn("CheckpointDiffQuery.collectThreadChangedFilePaths")(function* (threadId, turnIds) {
+		const activities = yield* threadActivities.listByThreadId({ threadId });
+		const changedPaths = /* @__PURE__ */ new Set();
+		for (const activity of activities) {
+			if (activity.tone !== "tool") continue;
+			if (turnIds !== null && (activity.turnId === null || !turnIds.has(activity.turnId))) continue;
+			for (const changedPath of collectActivityChangedFilePaths(activity.payload)) changedPaths.add(changedPath);
+		}
+		return changedPaths;
+	});
+	/**
+	* A thread whose activities name no paths at all gets the unfiltered diff.
+	* That is the deliberate escape valve: a thread working purely through shell
+	* commands never names the files it touched, and erasing its whole diff
+	* would be worse than the shared-worktree contamination this filter exists
+	* to remove.
+	*/
+	const attributeDiffToThread = (diff, changedPaths, workspaceCwd) => changedPaths.size === 0 ? diff : filterUnifiedDiffToChangedFiles(diff, changedPaths, workspaceCwd);
 	const getTurnDiff = Effect.fn("getTurnDiff")(function* (input) {
 		const operation = "CheckpointDiffQuery.getTurnDiff";
 		const ignoreWhitespace = input.ignoreWhitespace ?? true;
@@ -31583,13 +32317,16 @@ const make$39 = Effect.gen(function* () {
 			turnCount: input.toTurnCount,
 			checkpoint: "to"
 		});
-		const turnDiff = buildTurnDiffResult(input, yield* checkpointStore.diffCheckpoints({
+		const diff = yield* checkpointStore.diffCheckpoints({
 			cwd: workspaceCwd,
 			fromCheckpointRef,
 			toCheckpointRef,
 			fallbackFromToHead: false,
 			ignoreWhitespace
-		}).pipe(Effect.withSpan("checkpoint.turnDiff.diffCheckpoints")));
+		}).pipe(Effect.withSpan("checkpoint.turnDiff.diffCheckpoints"));
+		const turnIdsInRange = new Set(threadContext.value.checkpoints.filter((checkpoint) => checkpoint.checkpointTurnCount > input.fromTurnCount && checkpoint.checkpointTurnCount <= input.toTurnCount).map((checkpoint) => checkpoint.turnId));
+		const changedPaths = yield* collectThreadChangedFilePaths(input.threadId, turnIdsInRange);
+		const turnDiff = buildTurnDiffResult(input, attributeDiffToThread(diff, changedPaths, workspaceCwd));
 		if (!isTurnDiffResult(turnDiff)) return yield* new CheckpointDiffResultInvalidError({
 			operation,
 			threadId: input.threadId
@@ -31647,11 +32384,12 @@ const make$39 = Effect.gen(function* () {
 			fallbackFromToHead: false,
 			ignoreWhitespace
 		}).pipe(Effect.withSpan("checkpoint.fullThread.diffCheckpoints"));
+		const changedPaths = yield* collectThreadChangedFilePaths(input.threadId, null);
 		const turnDiff = buildTurnDiffResult({
 			threadId: input.threadId,
 			fromTurnCount: 0,
 			toTurnCount: input.toTurnCount
-		}, diff);
+		}, attributeDiffToThread(diff, changedPaths, workspaceCwd));
 		if (!isTurnDiffResult(turnDiff)) return yield* new CheckpointDiffResultInvalidError({
 			operation,
 			threadId: input.threadId
@@ -32231,7 +32969,7 @@ const normalizeDispatchCommand = (command) => Effect.gen(function* () {
 const buildTaskRow = (input, taskId, timestamp, repositoryKey = null) => ({
 	taskId,
 	projectId: input.projectId ?? null,
-	repositoryKey,
+	repositoryKey: repositoryKey ?? input.repositoryKey ?? null,
 	threadId: input.threadId ?? null,
 	title: input.title,
 	body: input.body ?? "",
@@ -32239,6 +32977,7 @@ const buildTaskRow = (input, taskId, timestamp, repositoryKey = null) => ({
 	priority: input.priority ?? "none",
 	assignee: input.assignee ?? null,
 	labels: input.labels ?? [],
+	orderKey: null,
 	createdAt: timestamp,
 	updatedAt: timestamp
 });
@@ -43349,6 +44088,7 @@ const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function*
 			priority: row.priority,
 			...row.assignee === null ? {} : { assignee: row.assignee },
 			labels: row.labels,
+			...row.orderKey === null ? {} : { orderKey: row.orderKey },
 			...readableIdPrefix === void 0 ? {} : { readableIdPrefix }
 		}));
 		if (response.status !== 201 && response.status !== 200) return yield* hubUnavailable(operation, `status ${response.status}`);
@@ -83332,538 +84072,6 @@ const make$2 = Effect.gen(function* () {
 	};
 });
 const ProviderCommandReactorLive = Layer.effect(ProviderCommandReactor, make$2);
-(() => {
-	try {
-		return process.env.NODE_ENV === "development";
-	} catch {
-		return false;
-	}
-})();
-const COMMIT_METADATA_SPLIT = /(?=^From [a-f0-9]+ .+$)/m;
-const GIT_DIFF_FILE_BREAK_REGEX = /(?=^diff --git)/gm;
-const FILENAME_HEADER_REGEX = /^(---|\+\+\+)\s+([^\t\r\n]+)/;
-const FILENAME_HEADER_REGEX_GIT = /^(---|\+\+\+)\s+[ab]\/([^\t\r\n]+)/;
-const ALTERNATE_FILE_NAMES_GIT = /^diff --git (?:"a\/(.+?)"|a\/(.+?)) (?:"b\/(.+?)"|b\/(.+?))$/;
-const INDEX_LINE_METADATA = /^index ([0-9a-f]+)\.\.([0-9a-f]+)(?: (\d+))?$/i;
-Object.freeze({
-	fromStart: 0,
-	fromEnd: 0
-});
-//#endregion
-//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/cleanLastNewline.js
-function cleanLastNewline(contents) {
-	let end = contents.length;
-	if (contents.charCodeAt(end - 1) === 10) {
-		end--;
-		if (contents.charCodeAt(end - 1) === 13) end--;
-	}
-	return contents.slice(0, end);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/detachString.js
-const stringDetachEncoder = new TextEncoder();
-const stringDetachDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
-const SURROGATE_CODE_UNIT_PATTERN = /[\uD800-\uDFFF]/;
-const STRING_DETACH_INITIAL_BUFFER_SIZE = 1024;
-let stringDetachBuffer = new Uint8Array(STRING_DETACH_INITIAL_BUFFER_SIZE);
-function releaseStringDetachBuffer() {
-	if (stringDetachBuffer.length !== STRING_DETACH_INITIAL_BUFFER_SIZE) stringDetachBuffer = new Uint8Array(STRING_DETACH_INITIAL_BUFFER_SIZE);
-}
-function detachString(value) {
-	if (value.length === 0) return value;
-	if (SURROGATE_CODE_UNIT_PATTERN.test(value)) return JSON.parse(JSON.stringify(value));
-	const requiredByteLength = value.length * 3;
-	if (stringDetachBuffer.length < requiredByteLength) stringDetachBuffer = new Uint8Array(requiredByteLength);
-	const { written } = stringDetachEncoder.encodeInto(value, stringDetachBuffer);
-	return stringDetachDecoder.decode(stringDetachBuffer.subarray(0, written));
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@pierre+diffs@1.3.0-beta.5_patch_hash=7cb6da88544119adda056b2f46f43956f99326227732da0b3_3b51331382fbad9d080c5033ee1e2a6a/node_modules/@pierre/diffs/dist/utils/parsePatchFiles.js
-function processPatch(data, cacheKeyPrefix, throwOnError) {
-	try {
-		return _processPatch(data, cacheKeyPrefix, throwOnError);
-	} finally {
-		releaseStringDetachBuffer();
-	}
-}
-function _processPatch(data, cacheKeyPrefix, throwOnError = false) {
-	const isGitDiff = isGitDiffPatch(data);
-	const rawFiles = isGitDiff ? splitGitDiffFiles(data) : splitUnifiedDiffFiles(data);
-	let patchMetadata;
-	const files = [];
-	for (const fileOrPatchMetadata of rawFiles) {
-		if (isGitDiff && !GIT_DIFF_FILE_BREAK_REGEX.test(fileOrPatchMetadata)) {
-			if (patchMetadata == null) patchMetadata = detachString(fileOrPatchMetadata);
-			else if (throwOnError) throw Error("parsePatchContent: unknown file blob");
-			else console.error("parsePatchContent: unknown file blob:", fileOrPatchMetadata);
-			continue;
-		} else if (!isGitDiff && !startsWithUnifiedDiffFileHeader(fileOrPatchMetadata)) {
-			if (patchMetadata == null) patchMetadata = detachString(fileOrPatchMetadata);
-			else if (throwOnError) throw Error("parsePatchContent: unknown file blob");
-			else console.error("parsePatchContent: unknown file blob:", fileOrPatchMetadata);
-			continue;
-		}
-		const currentFile = _processFile(fileOrPatchMetadata, {
-			cacheKey: cacheKeyPrefix != null ? `${cacheKeyPrefix}-${files.length}` : void 0,
-			isGitDiff,
-			throwOnError
-		});
-		if (currentFile != null) files.push(currentFile);
-	}
-	return {
-		patchMetadata,
-		files
-	};
-}
-function _processFile(fileDiffString, { cacheKey, isGitDiff = GIT_DIFF_FILE_BREAK_REGEX.test(fileDiffString), oldFile, newFile, throwOnError = false } = {}) {
-	let lastHunkEnd = 0;
-	const hunks = splitAtLinePrefix(fileDiffString, "@@ ");
-	let currentFile;
-	const isPartial = oldFile == null || newFile == null;
-	let deletionLineIndex = 0;
-	let additionLineIndex = 0;
-	for (const hunk of hunks) {
-		const lines = splitWithNewlines(hunk);
-		const firstLine = lines[0];
-		if (firstLine == null) {
-			if (throwOnError) throw Error("parsePatchContent: invalid hunk");
-			else console.error("parsePatchContent: invalid hunk", hunk);
-			continue;
-		}
-		const fileHeader = parseHunkHeader(firstLine);
-		let additionLines = 0;
-		let deletionLines = 0;
-		if (fileHeader == null || currentFile == null) {
-			if (currentFile != null) {
-				if (throwOnError) throw Error("parsePatchContent: Invalid hunk");
-				else console.error("parsePatchContent: Invalid hunk", hunk);
-				continue;
-			}
-			currentFile = {
-				name: "",
-				type: "change",
-				hunks: [],
-				splitLineCount: 0,
-				unifiedLineCount: 0,
-				isPartial,
-				additionLines: !isPartial && oldFile != null && newFile != null ? splitFileContents(newFile.contents) : [],
-				deletionLines: !isPartial && oldFile != null && newFile != null ? splitFileContents(oldFile.contents) : [],
-				cacheKey: maybeDetachOptionalString(cacheKey)
-			};
-			if (currentFile.additionLines.length === 1 && newFile?.contents === "") currentFile.additionLines.length = 0;
-			if (currentFile.deletionLines.length === 1 && oldFile?.contents === "") currentFile.deletionLines.length = 0;
-			for (const line of lines) {
-				if (line.startsWith("diff --git")) {
-					const filenameMatch$1 = line.trim().match(ALTERNATE_FILE_NAMES_GIT);
-					const prevName = filenameMatch$1?.[1] ?? filenameMatch$1?.[2];
-					const name = filenameMatch$1?.[3] ?? filenameMatch$1?.[4];
-					if (prevName == null || name == null) {
-						if (throwOnError) throw Error("parsePatchContent: invalid git diff header");
-						else console.error("parsePatchContent: invalid git diff header", line);
-						continue;
-					}
-					currentFile.name = detachString(name.trim());
-					if (prevName !== name) currentFile.prevName = detachString(prevName.trim());
-					continue;
-				}
-				const filenameMatch = line.startsWith("---") || line.startsWith("+++") ? line.match(isGitDiff ? FILENAME_HEADER_REGEX_GIT : FILENAME_HEADER_REGEX) : null;
-				if (filenameMatch != null) {
-					const [, type, fileName] = filenameMatch;
-					if (type === "---" && fileName !== "/dev/null") {
-						const detachedFileName = detachString(fileName.trim());
-						currentFile.prevName = detachedFileName;
-						currentFile.name = detachedFileName;
-					} else if (type === "+++" && fileName !== "/dev/null") currentFile.name = detachString(fileName.trim());
-				} else if (isGitDiff) {
-					if (line.startsWith("new mode ")) currentFile.mode = detachString(line.slice(8).trim());
-					if (line.startsWith("old mode ")) currentFile.prevMode = detachString(line.slice(8).trim());
-					if (line.startsWith("new file mode")) {
-						currentFile.type = "new";
-						currentFile.mode = detachString(line.slice(13).trim());
-					}
-					if (line.startsWith("deleted file mode")) {
-						currentFile.type = "deleted";
-						currentFile.mode = detachString(line.slice(17).trim());
-					}
-					if (line.startsWith("similarity index")) if (line.startsWith("similarity index 100%")) currentFile.type = "rename-pure";
-					else currentFile.type = "rename-changed";
-					if (line.startsWith("index ")) {
-						const [, prevObjectId, newObjectId, mode] = line.trim().match(INDEX_LINE_METADATA) ?? [];
-						if (prevObjectId != null) currentFile.prevObjectId = detachString(prevObjectId);
-						if (newObjectId != null) currentFile.newObjectId = detachString(newObjectId);
-						if (mode != null) currentFile.mode = detachString(mode);
-					}
-					if (line.startsWith("rename from ")) currentFile.prevName = detachString(line.slice(12).trim());
-					if (line.startsWith("rename to ")) currentFile.name = detachString(line.slice(10).trim());
-				}
-			}
-			continue;
-		}
-		let currentContent;
-		let lastLineType;
-		while (lines.length > 0 && (lines[lines.length - 1] === "\n" || lines[lines.length - 1] === "\r" || lines[lines.length - 1] === "\r\n" || lines[lines.length - 1] === "")) lines.pop();
-		const { additionStart, deletionStart } = fileHeader;
-		deletionLineIndex = isPartial ? deletionLineIndex : deletionStart - 1;
-		additionLineIndex = isPartial ? additionLineIndex : additionStart - 1;
-		const hunkData = {
-			collapsedBefore: 0,
-			splitLineCount: 0,
-			splitLineStart: 0,
-			unifiedLineCount: 0,
-			unifiedLineStart: 0,
-			additionCount: fileHeader.additionCount,
-			additionStart,
-			additionLines,
-			deletionCount: fileHeader.deletionCount,
-			deletionStart,
-			deletionLines,
-			deletionLineIndex,
-			additionLineIndex,
-			hunkContent: [],
-			hunkContext: maybeDetachOptionalString(fileHeader.hunkContext),
-			hunkSpecs: detachString(firstLine),
-			noEOFCRAdditions: false,
-			noEOFCRDeletions: false
-		};
-		let parsedAdditionLines = 0;
-		let parsedDeletionLines = 0;
-		for (let lineIndex = 1; lineIndex < lines.length; lineIndex++) {
-			const rawLine = lines[lineIndex];
-			if (parsedAdditionLines >= hunkData.additionCount && parsedDeletionLines >= hunkData.deletionCount && !rawLine.startsWith("\\")) {
-				if (throwOnError && isHunkBodyLine(rawLine) && !isFormatPatchVersionSeparator(rawLine)) throw Error("parsePatchContent: hunk has more lines than expected");
-				break;
-			}
-			const firstChar = rawLine[0];
-			if (firstChar !== "+" && firstChar !== "-" && firstChar !== " " && firstChar !== "\\") {
-				if (throwOnError) throw Error("parsePatchContent: invalid hunk line");
-				console.error(`parseLineType: Invalid firstChar: "${firstChar}", full line: "${rawLine}"`);
-				console.error("processFile: invalid rawLine:", rawLine);
-				continue;
-			}
-			const type = parseRawLineType(firstChar);
-			if (type === "addition") {
-				if (throwOnError && parsedAdditionLines >= hunkData.additionCount) throw Error("parsePatchContent: hunk has too many addition lines");
-				const line = getParsedLineContent(rawLine);
-				if (currentContent == null || currentContent.type !== "change") {
-					currentContent = createContentGroup("change", deletionLineIndex, additionLineIndex);
-					hunkData.hunkContent.push(currentContent);
-				}
-				additionLineIndex++;
-				parsedAdditionLines++;
-				if (isPartial) currentFile.additionLines.push(line);
-				currentContent.additions++;
-				additionLines++;
-				lastLineType = "addition";
-			} else if (type === "deletion") {
-				if (throwOnError && parsedDeletionLines >= hunkData.deletionCount) throw Error("parsePatchContent: hunk has too many deletion lines");
-				const line = getParsedLineContent(rawLine);
-				if (currentContent == null || currentContent.type !== "change") {
-					currentContent = createContentGroup("change", deletionLineIndex, additionLineIndex);
-					hunkData.hunkContent.push(currentContent);
-				}
-				deletionLineIndex++;
-				parsedDeletionLines++;
-				if (isPartial) currentFile.deletionLines.push(line);
-				currentContent.deletions++;
-				deletionLines++;
-				lastLineType = "deletion";
-			} else if (type === "context") {
-				if (throwOnError && (parsedDeletionLines >= hunkData.deletionCount || parsedAdditionLines >= hunkData.additionCount)) throw Error("parsePatchContent: hunk has too many context lines");
-				const line = getParsedLineContent(rawLine);
-				if (currentContent == null || currentContent.type !== "context") {
-					currentContent = createContentGroup("context", deletionLineIndex, additionLineIndex);
-					hunkData.hunkContent.push(currentContent);
-				}
-				additionLineIndex++;
-				deletionLineIndex++;
-				parsedAdditionLines++;
-				parsedDeletionLines++;
-				if (isPartial) {
-					currentFile.deletionLines.push(line);
-					currentFile.additionLines.push(line);
-				}
-				currentContent.lines++;
-				lastLineType = "context";
-			} else if (type === "metadata" && currentContent != null) {
-				if (currentContent.type === "context") {
-					hunkData.noEOFCRAdditions = true;
-					hunkData.noEOFCRDeletions = true;
-				} else if (lastLineType === "deletion") hunkData.noEOFCRDeletions = true;
-				else if (lastLineType === "addition") hunkData.noEOFCRAdditions = true;
-				if (isPartial && (lastLineType === "addition" || lastLineType === "context")) {
-					const lastIndex = currentFile.additionLines.length - 1;
-					if (lastIndex >= 0) currentFile.additionLines[lastIndex] = cleanLastNewline(currentFile.additionLines[lastIndex]);
-				}
-				if (isPartial && (lastLineType === "deletion" || lastLineType === "context")) {
-					const lastIndex = currentFile.deletionLines.length - 1;
-					if (lastIndex >= 0) currentFile.deletionLines[lastIndex] = cleanLastNewline(currentFile.deletionLines[lastIndex]);
-				}
-			}
-		}
-		if (throwOnError && (parsedAdditionLines !== hunkData.additionCount || parsedDeletionLines !== hunkData.deletionCount)) throw Error("parsePatchContent: hunk line count mismatch");
-		hunkData.additionLines = additionLines;
-		hunkData.deletionLines = deletionLines;
-		hunkData.collapsedBefore = Math.max(hunkData.additionStart - 1 - lastHunkEnd, 0);
-		currentFile.hunks.push(hunkData);
-		lastHunkEnd = hunkData.additionStart + hunkData.additionCount - 1;
-		for (const content of hunkData.hunkContent) if (content.type === "context") {
-			hunkData.splitLineCount += content.lines;
-			hunkData.unifiedLineCount += content.lines;
-		} else {
-			hunkData.splitLineCount += Math.max(content.additions, content.deletions);
-			hunkData.unifiedLineCount += content.deletions + content.additions;
-		}
-		hunkData.splitLineStart = currentFile.splitLineCount + hunkData.collapsedBefore;
-		hunkData.unifiedLineStart = currentFile.unifiedLineCount + hunkData.collapsedBefore;
-		currentFile.splitLineCount += hunkData.collapsedBefore + hunkData.splitLineCount;
-		currentFile.unifiedLineCount += hunkData.collapsedBefore + hunkData.unifiedLineCount;
-	}
-	if (currentFile == null) return;
-	if (throwOnError && isPartial && !isGitDiff && currentFile.hunks.length === 0) throw Error("parsePatchContent: unified file has no hunks");
-	if (currentFile.hunks.length > 0 && !isPartial && currentFile.additionLines.length > 0 && currentFile.deletionLines.length > 0) {
-		const lastHunk = currentFile.hunks[currentFile.hunks.length - 1];
-		const lastHunkEnd$1 = lastHunk.additionStart + lastHunk.additionCount - 1;
-		const totalFileLines = currentFile.additionLines.length;
-		const collapsedAfter = Math.max(totalFileLines - lastHunkEnd$1, 0);
-		currentFile.splitLineCount += collapsedAfter;
-		currentFile.unifiedLineCount += collapsedAfter;
-	}
-	if (!isGitDiff) {
-		if (currentFile.prevName != null && currentFile.name !== currentFile.prevName) if (currentFile.hunks.length > 0) currentFile.type = "rename-changed";
-		else currentFile.type = "rename-pure";
-		else if ((oldFile == null || oldFile.contents === "") && newFile != null && newFile.contents !== "") currentFile.type = "new";
-		else if (oldFile != null && oldFile.contents !== "" && (newFile == null || newFile.contents === "")) currentFile.type = "deleted";
-	}
-	if (currentFile.type !== "rename-pure" && currentFile.type !== "rename-changed") currentFile.prevName = void 0;
-	return currentFile;
-}
-/**
-* Parses a patch file string into an array of parsed patches.
-*
-* @param data - The raw patch file content (supports multi-commit patches)
-* @param cacheKeyPrefix - Optional prefix for generating cache keys. When provided,
-*   each file in the patch will get a cache key in the format `prefix-patchIndex-fileIndex`.
-*   This enables caching of rendered diff results in the worker pool.
-*/
-function parsePatchFiles(data, cacheKeyPrefix, throwOnError = false) {
-	const patches = [];
-	const rawPatches = hasCommitMetadataBoundary(data) ? data.split(COMMIT_METADATA_SPLIT) : [data];
-	for (const patch of rawPatches) try {
-		patches.push(processPatch(patch, cacheKeyPrefix != null ? `${cacheKeyPrefix}-${patches.length}` : void 0, throwOnError));
-	} catch (error) {
-		if (throwOnError) throw error;
-		else console.error(error);
-	}
-	return patches;
-}
-function hasCommitMetadataBoundary(data) {
-	return data.startsWith("From ") || data.includes("\nFrom ");
-}
-function splitFileContents(contents) {
-	const lines = splitWithNewlines(contents);
-	for (let index = 0; index < lines.length; index++) lines[index] = detachString(lines[index]);
-	return lines;
-}
-function splitWithNewlines(contents) {
-	if (contents.length === 0) return [""];
-	const lines = [];
-	let startIndex = 0;
-	for (;;) {
-		const newlineIndex = contents.indexOf("\n", startIndex);
-		if (newlineIndex === -1) break;
-		lines.push(contents.slice(startIndex, newlineIndex + 1));
-		startIndex = newlineIndex + 1;
-	}
-	if (startIndex < contents.length) lines.push(contents.slice(startIndex));
-	return lines;
-}
-function splitGitDiffFiles(contents) {
-	return splitAtLinePrefix(contents, "diff --git");
-}
-function splitUnifiedDiffFiles(contents) {
-	if (contents.length === 0) return [""];
-	const parts = [];
-	let partStartIndex = 0;
-	let lineStartIndex = 0;
-	let remainingDeletionLines = 0;
-	let remainingAdditionLines = 0;
-	let hasOpenedUnifiedFile = false;
-	while (lineStartIndex < contents.length) {
-		const nextLineStartIndex = getNextLineStartIndex(contents, lineStartIndex);
-		if (remainingDeletionLines <= 0 && remainingAdditionLines <= 0) {
-			if (isUnifiedDiffFileHeaderAt(contents, lineStartIndex)) {
-				if (lineStartIndex > partStartIndex) parts.push(contents.slice(partStartIndex, lineStartIndex));
-				partStartIndex = lineStartIndex;
-				hasOpenedUnifiedFile = true;
-				lineStartIndex = getNextLineStartIndex(contents, nextLineStartIndex);
-				continue;
-			}
-			if (hasOpenedUnifiedFile && contents.startsWith("@@ -", lineStartIndex)) {
-				const fileHeader = parseHunkHeader(contents.slice(lineStartIndex, nextLineStartIndex));
-				if (fileHeader != null) {
-					remainingDeletionLines = fileHeader.deletionCount;
-					remainingAdditionLines = fileHeader.additionCount;
-				}
-			}
-			lineStartIndex = nextLineStartIndex;
-			continue;
-		}
-		const firstChar = contents[lineStartIndex];
-		if (firstChar === "\\") {
-			lineStartIndex = nextLineStartIndex;
-			continue;
-		}
-		if (firstChar === " ") {
-			remainingDeletionLines = Math.max(remainingDeletionLines - 1, 0);
-			remainingAdditionLines = Math.max(remainingAdditionLines - 1, 0);
-		} else if (firstChar === "-") remainingDeletionLines = Math.max(remainingDeletionLines - 1, 0);
-		else if (firstChar === "+") remainingAdditionLines = Math.max(remainingAdditionLines - 1, 0);
-		lineStartIndex = nextLineStartIndex;
-	}
-	parts.push(contents.slice(partStartIndex));
-	return parts;
-}
-function startsWithUnifiedDiffFileHeader(contents) {
-	return isUnifiedDiffFileHeaderAt(contents, 0);
-}
-function isUnifiedDiffFileHeaderAt(contents, lineStartIndex) {
-	const nextLineStartIndex = getNextLineStartIndex(contents, lineStartIndex);
-	return isUnifiedDiffHeaderLineAt(contents, lineStartIndex, "---") && isUnifiedDiffHeaderLineAt(contents, nextLineStartIndex, "+++");
-}
-function isUnifiedDiffHeaderLineAt(contents, lineStartIndex, prefix) {
-	if (!contents.startsWith(prefix, lineStartIndex)) return false;
-	const separator = contents[lineStartIndex + prefix.length];
-	if (separator !== " " && separator !== "	") return false;
-	for (let index = lineStartIndex + prefix.length + 1; index < contents.length; index++) {
-		const char = contents[index];
-		if (char === "\n" || char === "\r") break;
-		if (char !== " " && char !== "	") return true;
-	}
-	return false;
-}
-function getNextLineStartIndex(contents, lineStartIndex) {
-	const newlineIndex = contents.indexOf("\n", lineStartIndex);
-	return newlineIndex === -1 ? contents.length : newlineIndex + 1;
-}
-function isHunkBodyLine(line) {
-	const firstChar = line[0];
-	return firstChar === "+" || firstChar === "-" || firstChar === " ";
-}
-function isFormatPatchVersionSeparator(line) {
-	if (!line.startsWith("--")) return false;
-	for (let index = 2; index < line.length; index++) {
-		const char = line[index];
-		if (char !== " " && char !== "	" && char !== "\n" && char !== "\r") return false;
-	}
-	return true;
-}
-function parseHunkHeader(line) {
-	if (!line.startsWith("@@ -")) return;
-	let index = 4;
-	const deletionStartResult = readPositiveInteger(line, index);
-	if (deletionStartResult == null) return;
-	const deletionStart = deletionStartResult.value;
-	index = deletionStartResult.endIndex;
-	let deletionCount = 1;
-	if (line[index] === ",") {
-		const deletionCountResult = readPositiveInteger(line, index + 1);
-		if (deletionCountResult == null) return;
-		deletionCount = deletionCountResult.value;
-		index = deletionCountResult.endIndex;
-	}
-	if (line[index] !== " " || line[index + 1] !== "+") return;
-	index += 2;
-	const additionStartResult = readPositiveInteger(line, index);
-	if (additionStartResult == null) return;
-	const additionStart = additionStartResult.value;
-	index = additionStartResult.endIndex;
-	let additionCount = 1;
-	if (line[index] === ",") {
-		const additionCountResult = readPositiveInteger(line, index + 1);
-		if (additionCountResult == null) return;
-		additionCount = additionCountResult.value;
-		index = additionCountResult.endIndex;
-	}
-	if (line[index] !== " " || line[index + 1] !== "@" || line[index + 2] !== "@") return;
-	let hunkContext;
-	const contextStartIndex = index + 3;
-	if (line[contextStartIndex] === " ") hunkContext = trimLineEnd(line.slice(contextStartIndex + 1));
-	return {
-		additionCount,
-		additionStart,
-		deletionCount,
-		deletionStart,
-		hunkContext
-	};
-}
-function readPositiveInteger(value, startIndex) {
-	let index = startIndex;
-	let parsedValue = 0;
-	for (; index < value.length; index++) {
-		const digit = value.charCodeAt(index) - 48;
-		if (digit < 0 || digit > 9) break;
-		parsedValue = parsedValue * 10 + digit;
-	}
-	if (index === startIndex) return;
-	return {
-		value: parsedValue,
-		endIndex: index
-	};
-}
-function trimLineEnd(value) {
-	if (value.endsWith("\r\n")) return value.slice(0, -2);
-	if (value.endsWith("\n")) return value.slice(0, -1);
-	return value;
-}
-function isGitDiffPatch(data) {
-	return data.startsWith("diff --git") || data.includes("\ndiff --git");
-}
-function splitAtLinePrefix(contents, prefix) {
-	if (contents.length === 0) return [""];
-	const newlinePrefix = `\n${prefix}`;
-	const firstBoundaryIndex = contents.startsWith(prefix) ? 0 : findLinePrefixIndex(contents, newlinePrefix, 0);
-	if (firstBoundaryIndex === -1) return [contents];
-	const parts = [];
-	if (firstBoundaryIndex > 0) parts.push(contents.slice(0, firstBoundaryIndex));
-	let startIndex = firstBoundaryIndex;
-	for (;;) {
-		const nextBoundaryIndex = findLinePrefixIndex(contents, newlinePrefix, startIndex + 1);
-		if (nextBoundaryIndex === -1) break;
-		parts.push(contents.slice(startIndex, nextBoundaryIndex));
-		startIndex = nextBoundaryIndex;
-	}
-	parts.push(contents.slice(startIndex));
-	return parts;
-}
-function findLinePrefixIndex(contents, newlinePrefix, fromIndex) {
-	const index = contents.indexOf(newlinePrefix, fromIndex);
-	return index === -1 ? -1 : index + 1;
-}
-function maybeDetachOptionalString(value) {
-	return value == null ? value : detachString(value);
-}
-function parseRawLineType(firstChar) {
-	return firstChar === " " ? "context" : firstChar === "\\" ? "metadata" : firstChar === "+" ? "addition" : "deletion";
-}
-function getParsedLineContent(rawLine) {
-	const processedLine = rawLine.slice(1);
-	return detachString(processedLine === "" ? "\n" : processedLine);
-}
-function createContentGroup(type, deletionLineIndex, additionLineIndex) {
-	if (type === "change") return {
-		type: "change",
-		additions: 0,
-		deletions: 0,
-		additionLineIndex,
-		deletionLineIndex
-	};
-	return {
-		type: "context",
-		lines: 0,
-		additionLineIndex,
-		deletionLineIndex
-	};
-}
 //#endregion
 //#region src/checkpointing/Diffs.ts
 function parseTurnDiffFilesFromUnifiedDiff(diff) {
@@ -83904,6 +84112,7 @@ const make$1 = Effect.gen(function* () {
 	const receiptBus = yield* RuntimeReceiptBus;
 	const workspaceEntries = yield* WorkspaceEntries;
 	const vcsStatusBroadcaster = yield* VcsStatusBroadcaster;
+	const threadActivities = yield* ProjectionThreadActivityRepository;
 	const appendRevertFailureActivity = (input) => Effect.all({
 		commandId: serverCommandId("checkpoint-revert-failure"),
 		activityId: serverEventId
@@ -83992,13 +84201,21 @@ const make$1 = Effect.gen(function* () {
 			checkpointRef: targetCheckpointRef
 		});
 		yield* workspaceEntries.refresh(input.cwd);
+		const turnChangedPaths = yield* threadActivities.listByThreadId({ threadId: input.threadId }).pipe(Effect.map((activities) => {
+			const changedPaths = /* @__PURE__ */ new Set();
+			for (const activity of activities) {
+				if (activity.tone !== "tool" || activity.turnId !== input.turnId) continue;
+				for (const changedPath of collectActivityChangedFilePaths(activity.payload)) changedPaths.add(changedPath);
+			}
+			return normalizeChangedFilePaths(changedPaths, input.cwd);
+		}), Effect.orElseSucceed(() => /* @__PURE__ */ new Set()));
 		const files = yield* checkpointStore.diffCheckpoints({
 			cwd: input.cwd,
 			fromCheckpointRef,
 			toCheckpointRef: targetCheckpointRef,
 			fallbackFromToHead: false,
 			ignoreWhitespace: false
-		}).pipe(Effect.map((diff) => parseTurnDiffFilesFromUnifiedDiff(diff).map((file) => ({
+		}).pipe(Effect.map((diff) => parseTurnDiffFilesFromUnifiedDiff(diff).filter((file) => turnChangedPaths.size === 0 || turnChangedPaths.has(file.path)).map((file) => ({
 			path: file.path,
 			kind: "modified",
 			additions: file.additions,