@gajae-code/coding-agent 0.12.19 → 0.12.20

package/src/session/blob-store.ts

@@ -1523,3 +1523,92 @@ export function resolveResidentImageDataSync(
 	}
 	return buffer.toString("base64");
 }
+
+// =============================================================================
+// Canonical-store mark-and-sweep primitives (`gjc gc --disk`)
+// =============================================================================
+//
+// The resident-cache sweep above bounds *cache* directories. These primitives
+// expose the canonical `~/.gjc/agent/blobs` store to an out-of-process retention
+// pass so it can mark live hashes from surviving transcripts and sweep the rest.
+// They own no policy: the caller decides what "unreferenced" means.
+
+/** One canonical blob file (`<blobsDir>/<sha256-hex>`) observed on disk. */
+export interface CanonicalBlobEntry {
+	readonly hash: string;
+	readonly path: string;
+	readonly bytes: number;
+	readonly mtimeMs: number;
+}
+
+const CANONICAL_BLOB_NAME = /^[0-9a-f]{64}$/;
+const BLOB_REFERENCE = /blob:sha256:([0-9a-f]{64})/g;
+
+/** Longest possible `blob:sha256:<hash>` reference, used to bound chunked scans. */
+export const BLOB_REFERENCE_MAX_LENGTH = BLOB_PREFIX.length + 64;
+
+/** Collect every `blob:sha256:<hash>` reference that appears in `text`. */
+export function collectBlobReferences(text: string, into: Set<string>): void {
+	for (const match of text.matchAll(BLOB_REFERENCE)) into.add(match[1]!);
+}
+
+/**
+ * List canonical blob files. Anything that is not a plain, owner-visible regular
+ * file named after its own hash (temp files, symlinks, subdirectories) is
+ * skipped: a sweep must never reason about entries it cannot classify.
+ */
+export async function listCanonicalBlobs(dir: string): Promise<CanonicalBlobEntry[]> {
+	let names: string[];
+	try {
+		names = await fsp.readdir(dir);
+	} catch (error) {
+		if (isEnoent(error)) return [];
+		throw error;
+	}
+
+	const entries: CanonicalBlobEntry[] = [];
+	for (const name of names) {
+		if (!CANONICAL_BLOB_NAME.test(name)) continue;
+		const blobPath = path.join(dir, name);
+		let stat: fs.Stats;
+		try {
+			stat = await fsp.lstat(blobPath);
+		} catch {
+			continue;
+		}
+		if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) continue;
+		entries.push({ hash: name, path: blobPath, bytes: stat.size, mtimeMs: stat.mtimeMs });
+	}
+	return entries;
+}
+
+/**
+ * Remove one canonical blob, fail-closed on identity drift. The entry captured
+ * at scan time must still describe the file at unlink time (same inode, size and
+ * mtime, still a single-link regular file), otherwise the blob is left in place.
+ *
+ * `failed` distinguishes an actual IO failure (which a caller should surface as
+ * a failed reclaim) from a revalidation refusal (which is an ordinary KEEP).
+ */
+export async function removeCanonicalBlob(
+	entry: CanonicalBlobEntry,
+): Promise<{ removed: true } | { removed: false; reason: string; failed?: true }> {
+	let stat: fs.Stats;
+	try {
+		stat = await fsp.lstat(entry.path);
+	} catch (error) {
+		if (isEnoent(error)) return { removed: false, reason: "blob_disappeared" };
+		return { removed: false, reason: `blob_unverifiable: ${String(error)}`, failed: true };
+	}
+	if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+		return { removed: false, reason: "blob_not_plain_file" };
+	}
+	if (stat.size !== entry.bytes || stat.mtimeMs !== entry.mtimeMs) return { removed: false, reason: "blob_changed" };
+	try {
+		await fsp.unlink(entry.path);
+		return { removed: true };
+	} catch (error) {
+		if (isEnoent(error)) return { removed: false, reason: "blob_disappeared" };
+		return { removed: false, reason: `blob_unlink_failed: ${String(error)}`, failed: true };
+	}
+}

package/src/session/internal/managed-session-scope.ts

@@ -37,6 +37,7 @@ import {
 	copyManagedFileNoReplace,
 	ensureManagedDirectory,
 	fsyncManagedArtifactTree,
+	inspectManagedFileNoFollow,
 	MANAGED_ARTIFACT_COPY_BATCH_SIZE,
 	MANAGED_ARTIFACT_MAX_FILES,
 	MANAGED_ARTIFACT_MAX_TOTAL_BYTES,
@@ -784,7 +785,7 @@ function matchesPreflightIdentity(candidate: ManagedCandidate, preflight: Candid
 
 function inspectCandidate(filePath: string, provenance: "v2" | "legacy"): ManagedCandidate | { code: string } {
 	try {
-		const snapshot = captureManagedFileNoFollow(filePath);
+		const snapshot = inspectManagedFileNoFollow(filePath, HEADER_MAX_BYTES);
 		const lineEnd = snapshot.bytes.subarray(0, HEADER_MAX_BYTES).indexOf(0x0a);
 		if (lineEnd < 0) return { code: "invalid_header" };
 		const value: unknown = JSON.parse(snapshot.bytes.subarray(0, lineEnd).toString("utf8"));
@@ -816,7 +817,7 @@ function inspectCandidate(filePath: string, provenance: "v2" | "legacy"): Manage
 				...snapshot.identity,
 				nlink: snapshot.identity.nlink,
 				mtimeMs: Number(named.mtimeMs),
-				sha256: createHash("sha256").update(snapshot.bytes).digest("hex"),
+				sha256: snapshot.identity.sha256,
 			},
 		};
 	} catch (error) {
@@ -3376,32 +3377,37 @@ function receiptPair(scope: ManagedScope, candidate: ManagedCandidate): ManagedC
 	const directory = path.join(managedInternalDirectory(scope), MANAGED_RECEIPTS_DIRECTORY);
 	try {
 		for (const name of fs.readdirSync(directory)) {
-			const pathname = path.join(directory, name);
-			const value: unknown = JSON.parse(captureManagedFileNoFollow(pathname).bytes.toString("utf8"));
-			if (!value || typeof value !== "object") continue;
-			const record = value as { source?: { path?: unknown }; destination?: { path?: unknown } };
-			const otherPath =
-				record.source?.path === candidate.path
-					? record.destination?.path
-					: record.destination?.path === candidate.path
-						? record.source?.path
-						: undefined;
-			if (typeof otherPath !== "string") continue;
-			const other = inspectCandidate(otherPath, candidate.provenance === "v2" ? "legacy" : "v2");
-			if (
-				"code" in other ||
-				!receiptMatches(
-					pathname,
-					candidate.provenance === "legacy" ? candidate : other,
-					candidate.provenance === "v2" ? candidate : other,
-					scope,
+			try {
+				const pathname = path.join(directory, name);
+				const value: unknown = JSON.parse(captureManagedFileNoFollow(pathname).bytes.toString("utf8"));
+				if (!value || typeof value !== "object") continue;
+				const record = value as { source?: { path?: unknown }; destination?: { path?: unknown } };
+				const otherPath =
+					record.source?.path === candidate.path
+						? record.destination?.path
+						: record.destination?.path === candidate.path
+							? record.source?.path
+							: undefined;
+				if (typeof otherPath !== "string") continue;
+				const other = inspectCandidate(otherPath, candidate.provenance === "v2" ? "legacy" : "v2");
+				if (
+					"code" in other ||
+					!receiptMatches(
+						pathname,
+						candidate.provenance === "legacy" ? candidate : other,
+						candidate.provenance === "v2" ? candidate : other,
+						scope,
+					)
 				)
-			)
-				continue;
-			return other;
+					continue;
+				return other;
+			} catch {
+				// Native cleanup residues, symlinks, and malformed files grant no authority;
+				// continue to the deterministic committed receipt instead of aborting the scan.
+			}
 		}
 	} catch {
-		/* no committed pair grants no shadow authority */
+		/* a missing receipts directory grants no shadow authority */
 	}
 	return undefined;
 }
@@ -3857,8 +3863,12 @@ async function openManagedCandidateForWriteInternal(
 				assertPublicationConsent,
 				scopeRoot(scope),
 			);
+			assertPublicationConsent();
 		} catch (error) {
-			if ((error as Error).message !== "destination_conflict") throw error;
+			if ((error as Error).message !== "destination_conflict") {
+				await removeStagedReceipts(scope, afterLock);
+				throw error;
+			}
 		}
 
 		revalidatePickerConsent(scope, afterLock, expectedIdentity);

package/src/session/internal/managed-session-storage.ts

@@ -2,14 +2,14 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-
 import type {
 	NativeDirectoryTreeSnapshot,
 	NativeExactUnlinkResult,
 	NativeOwnerOnlySecurityResult,
+	RecoveryFsIdentity,
 	RecoveryFsRoot,
 } from "@gajae-code/natives";
-
+import type { SessionStorageStat } from "../session-storage";
 import {
 	classifyNativePublishOutcome,
 	formatNativePublishDiagnostic,
@@ -208,6 +208,68 @@ export interface ManagedFileSnapshot {
 		sha256: string;
 	};
 }
+/**
+ * Descriptor identity of one managed file object. Deliberately excludes the
+ * content sha256: append receipts must bind the post-operation object without
+ * re-reading the whole payload.
+ */
+export interface ManagedFileIdentity {
+	dev: bigint;
+	ino: bigint;
+	nlink: bigint;
+	size: number;
+	mtimeNs: bigint;
+	ctimeNs: bigint;
+}
+
+/**
+ * Post-operation evidence for one managed append. `descriptor` is the
+ * `SessionStorageStat`-shaped snapshot of the retained/successor object captured
+ * AFTER the append has been synchronized (never a pathname `statSync`); `identity`
+ * carries the same fields as the object identity. The SessionManager feeds
+ * `descriptor` directly into the commit-marker snapshot.
+ */
+export interface ManagedAppendReceipt {
+	descriptor: SessionStorageStat;
+	identity: ManagedFileIdentity;
+}
+
+export interface ManagedBoundedAppendExpectation {
+	readonly dev: string;
+	readonly ino: string;
+	readonly size: string;
+	readonly mtimeNs: string;
+	readonly ctimeNs: string;
+	readonly sha256: string;
+}
+
+function managedFileIdentityFromNative(identity: RecoveryFsIdentity): ManagedFileIdentity {
+	return {
+		dev: BigInt(identity.dev),
+		ino: BigInt(identity.ino),
+		nlink: BigInt(identity.nlink),
+		size: Number(identity.size),
+		mtimeNs: BigInt(identity.mtimeNs),
+		ctimeNs: BigInt(identity.ctimeNs),
+	};
+}
+
+function managedAppendReceiptFromIdentity(identity: ManagedFileIdentity): ManagedAppendReceipt {
+	return {
+		identity,
+		descriptor: {
+			dev: identity.dev,
+			ino: identity.ino,
+			nlink: identity.nlink,
+			size: identity.size,
+			mtimeMs: Number(identity.mtimeNs) / 1_000_000,
+			mtimeNs: identity.mtimeNs,
+			ctimeNs: identity.ctimeNs,
+			mtime: new Date(Number(identity.mtimeNs) / 1_000_000),
+			isFile: true,
+		},
+	};
+}
 
 type SerializedReplacementIdentity = {
 	dev: string;
@@ -1207,40 +1269,90 @@ export class ManagedSessionDescendantStore {
 		this.#assertBound();
 	}
 
-	appendSync(relativePath: string, bytes: Uint8Array): void {
+	captureBoundedAppendExpectation(relativePath: string): ManagedBoundedAppendExpectation | undefined {
+		this.#assertBound();
+		if (!this.#authority) return undefined;
+		const observed = this.#authority.stat(this.#relative(this.#resolve(relativePath)));
+		if (!observed.ok || !observed.identity) return undefined;
+		const sha256 = observed.identity.sha256;
+		if (typeof sha256 !== "string" || !/^[0-9a-f]{64}$/i.test(sha256)) return undefined;
+		return {
+			dev: observed.identity.dev,
+			ino: observed.identity.ino,
+			size: observed.identity.size,
+			mtimeNs: observed.identity.mtimeNs,
+			ctimeNs: observed.identity.ctimeNs,
+			sha256: sha256.toLowerCase(),
+		};
+	}
+
+	appendExpectedSync(
+		relativePath: string,
+		bytes: Uint8Array,
+		expected: ManagedBoundedAppendExpectation,
+	): ManagedAppendReceipt {
+		this.#beforeMutation();
+		this.#assertBound();
+		if (!this.#authority) throw new Error("managed_bounded_append_unavailable");
+		const relative = this.#relative(this.#resolve(relativePath));
+		const appended = this.#authority.appendManaged(
+			relative,
+			bytes,
+			expected.dev,
+			expected.ino,
+			expected.size,
+			expected.mtimeNs,
+			expected.ctimeNs,
+			expected.sha256,
+		);
+		if (!appended.ok) throw new Error(appended.code ?? "managed_append_failed");
+		const stat = this.#authority.stat(relative);
+		if (!stat.ok || !stat.identity) throw new Error(stat.code ?? "managed_append_identity_unavailable");
+		this.#assertBound();
+		return managedAppendReceiptFromIdentity(managedFileIdentityFromNative(stat.identity));
+	}
+
+	appendSync(relativePath: string, bytes: Uint8Array): ManagedAppendReceipt {
 		this.#beforeMutation();
 		this.#assertBound();
 		const resolved = this.#resolve(relativePath);
-		const existing = this.readExpected(relativePath);
-		if (!existing) throw new Error("managed_append_missing");
 		if (this.#authority) {
+			const relative = this.#relative(resolved);
+			const observed = this.#authority.stat(relative);
+			if (!observed.ok || !observed.identity) throw new Error(observed.code ?? "managed_append_missing");
+			const nativeSha256 = observed.identity.sha256;
+			const expectedSha256 =
+				typeof nativeSha256 === "string" && /^[0-9a-f]{64}$/i.test(nativeSha256)
+					? nativeSha256.toLowerCase()
+					: this.readExpected(relativePath)?.identity.sha256;
+			if (!expectedSha256) throw new Error("managed_append_missing");
 			const appended = this.#authority.appendManaged(
-				this.#relative(resolved),
+				relative,
 				bytes,
-				existing.identity.dev.toString(),
-				existing.identity.ino.toString(),
-				existing.identity.size.toString(),
-				existing.identity.mtimeNs.toString(),
-				existing.identity.ctimeNs.toString(),
-				existing.identity.sha256,
+				observed.identity.dev,
+				observed.identity.ino,
+				observed.identity.size,
+				observed.identity.mtimeNs,
+				observed.identity.ctimeNs,
+				expectedSha256,
 			);
 			if (!appended.ok) throw new Error(appended.code ?? "managed_append_failed");
+			// Post-fsync descriptor capture through retained authority: the native append
+			// is synchronous and durable, so the stat reflects the committed object.
+			const stat = this.#authority.stat(relative);
+			if (!stat.ok || !stat.identity) throw new Error(stat.code ?? "managed_append_identity_unavailable");
+			const receipt = managedAppendReceiptFromIdentity(managedFileIdentityFromNative(stat.identity));
 			this.#assertBound();
-			return;
+			return receipt;
 		}
-		// Darwin has no retained native root authority. Do not append in place:
-		// a short write can leave a malformed JSONL tail with no safe recovery
-		// boundary. Replace the exact captured file instead so the old transcript
-		// or the complete successor remains recoverable after every reported error.
-		replaceManagedFileSync(
-			resolved,
-			Buffer.concat([existing.bytes, Buffer.from(bytes)]),
-			this.#subtreeRoot,
-			this.#policy,
-			undefined,
-			existing.identity,
-		);
+		// Darwin has no retained native root authority. Copy the predecessor through a
+		// fixed 64 KiB buffer into an exact-replacement staging file, append the new
+		// record bytes, and publish through the existing cleanup-receipt protocol.
+		// The transcript-linear disk pass is unavoidable; resident memory is bounded.
+		const successor = appendManagedFileStreamingSync(resolved, bytes, this.#subtreeRoot, this.#policy);
+		const receipt = managedAppendReceiptFromIdentity(successor);
 		this.#assertBound();
+		return receipt;
 	}
 
 	#relative(resolved: string): string {
@@ -1349,6 +1461,23 @@ export class ManagedSessionDescendantStore {
 		if (!replaced.ok) throw new Error(replaced.code ?? "managed_replace_failed");
 	}
 
+	/** Capture descriptor identity without copying file bytes when retained authority is available. */
+	descriptorExpected(relativePath: string): SessionStorageStat | null {
+		this.#assertBound();
+		const resolved = this.#resolve(relativePath);
+		if (!this.#authority) {
+			const snapshot = this.readExpected(relativePath);
+			return snapshot ? managedAppendReceiptFromIdentity(snapshot.identity).descriptor : null;
+		}
+		const stat = this.#authority.stat(this.#relative(resolved));
+		if (!stat.ok) {
+			if (stat.code === "not_found") return null;
+			throw new Error(stat.code ?? "managed_stat_failed");
+		}
+		if (!stat.identity) throw new Error("managed_stat_identity_unavailable");
+		return managedAppendReceiptFromIdentity(managedFileIdentityFromNative(stat.identity)).descriptor;
+	}
+
 	/** Read an exact managed file without exposing its pathname as authority. */
 	readExpected(relativePath: string): ManagedFileSnapshot | null {
 		this.#assertBound();
@@ -1905,6 +2034,62 @@ function captureManagedFileNoFollowLimit(pathname: string, maxBytes?: number): M
 	}
 }
 
+/** Streams a managed file once while retaining only a bounded header prefix and the full descriptor-bound digest. */
+export function inspectManagedFileNoFollow(pathname: string, prefixLimit: number): ManagedFileSnapshot {
+	if (!Number.isSafeInteger(prefixLimit) || prefixLimit < 0) throw new Error("invalid_capture_limit");
+	const fd = fs.openSync(pathname, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+	try {
+		const before = fs.fstatSync(fd, { bigint: true });
+		if (!before.isFile() || before.nlink > 1) throw new Error("source_changed");
+		const prefix = Buffer.alloc(Math.min(Number(before.size), prefixLimit));
+		const hash = createHash("sha256");
+		const chunk = Buffer.alloc(64 * 1024);
+		let offset = 0;
+		for (;;) {
+			const count = fs.readSync(fd, chunk, 0, chunk.byteLength, null);
+			if (count === 0) break;
+			hash.update(chunk.subarray(0, count));
+			if (offset < prefix.byteLength) {
+				const copied = Math.min(count, prefix.byteLength - offset);
+				chunk.copy(prefix, offset, 0, copied);
+			}
+			offset += count;
+		}
+		if (offset !== Number(before.size)) throw new Error("source_changed");
+		const after = fs.fstatSync(fd, { bigint: true });
+		if (!sameIdentity(identity(before), identity(after))) throw new Error("source_changed");
+		const named = fs.lstatSync(pathname, { bigint: true });
+		if (!named.isFile() || named.isSymbolicLink() || !sameIdentity(identity(before), identity(named)))
+			throw new Error("source_changed");
+		return { bytes: prefix, identity: identity(before, hash.digest("hex")) };
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+function captureManagedFileIdentityStreamingNoFollow(pathname: string): ManagedFileSnapshot["identity"] {
+	const fd = fs.openSync(pathname, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+	try {
+		const before = fs.fstatSync(fd, { bigint: true });
+		if (!before.isFile() || before.nlink > 1) throw new Error("source_changed");
+		const hash = createHash("sha256");
+		const chunk = Buffer.alloc(64 * 1024);
+		for (;;) {
+			const count = fs.readSync(fd, chunk, 0, chunk.byteLength, null);
+			if (count === 0) break;
+			hash.update(chunk.subarray(0, count));
+		}
+		const after = fs.fstatSync(fd, { bigint: true });
+		if (!sameIdentity(identity(before), identity(after))) throw new Error("source_changed");
+		const named = fs.lstatSync(pathname, { bigint: true });
+		if (!named.isFile() || named.isSymbolicLink() || !sameIdentity(identity(before), identity(named)))
+			throw new Error("source_changed");
+		return identity(before, hash.digest("hex"));
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
 /** Atomically publishes bytes without replacing an existing destination. */
 export async function publishManagedFileNoReplace(
 	destination: string,
@@ -2058,9 +2243,9 @@ export function publishManagedFileNoReplaceSync(
 }
 
 /** Replace one managed regular file while retaining the secured staging fd through publication. */
-export function replaceManagedFileSync(
+function replaceManagedFileGeneratedSync(
 	destination: string,
-	bytes: Uint8Array,
+	writeContent: (fd: number) => { size: number; sha256: string },
 	root: ManagedDirectoryRoot,
 	policy: ManagedSessionSecurityPolicy = "default",
 	assertFence?: () => void,
@@ -2089,8 +2274,7 @@ export function replaceManagedFileSync(
 			0o600,
 		);
 		secureFileDescriptor(staging, fd, "apply");
-		let offset = 0;
-		while (offset < bytes.byteLength) offset += fs.writeSync(fd, bytes, offset, bytes.byteLength - offset);
+		const generated = writeContent(fd);
 		fs.fsyncSync(fd);
 		secureFileDescriptor(staging, fd, "verify");
 		const staged = fs.fstatSync(fd, { bigint: true });
@@ -2103,7 +2287,8 @@ export function replaceManagedFileSync(
 		assertFence?.();
 		if (expectedDestination) {
 			const parentIdentity = fs.lstatSync(parent, { bigint: true });
-			const successor = identity(staged, createHash("sha256").update(bytes).digest("hex"));
+			if (Number(staged.size) !== generated.size) throw new Error("managed_replace_generated_size_changed");
+			const successor = identity(staged, generated.sha256);
 			const receiptStagingPath = path.join(parent, `.gjc-replace-receipt-pending-${randomUUID()}.json`);
 			preserveStaging = true;
 			const publishedReceiptIdentity = publishManagedFileNoReplaceSync(
@@ -2164,8 +2349,8 @@ export function replaceManagedFileSync(
 				},
 			);
 			if (!replaced.ok) throw new ManagedReplaceError(replaced, receiptCleanup.path);
-			const named = captureManagedFileNoFollow(destination);
-			if (!sameReplacementIdentity(named.identity, successor) || named.identity.sha256 !== successor.sha256)
+			const named = captureManagedFileIdentityStreamingNoFollow(destination);
+			if (!sameReplacementIdentity(named, successor) || named.sha256 !== successor.sha256)
 				throw new Error("destination_identity_changed");
 			fsyncDirectory(parent);
 		} else fs.renameSync(staging, destination);
@@ -2229,6 +2414,92 @@ export function replaceManagedFileSync(
 	if (failure !== undefined) throw failure;
 }
 
+export function replaceManagedFileSync(
+	destination: string,
+	bytes: Uint8Array,
+	root: ManagedDirectoryRoot,
+	policy: ManagedSessionSecurityPolicy = "default",
+	assertFence?: () => void,
+	expectedDestination?: ManagedFileSnapshot["identity"],
+): void {
+	replaceManagedFileGeneratedSync(
+		destination,
+		fd => {
+			const hash = createHash("sha256");
+			let offset = 0;
+			while (offset < bytes.byteLength) {
+				const written = fs.writeSync(fd, bytes, offset, bytes.byteLength - offset);
+				if (written === 0) throw new Error("managed_replace_short_write");
+				hash.update(bytes.subarray(offset, offset + written));
+				offset += written;
+			}
+			return { size: offset, sha256: hash.digest("hex") };
+		},
+		root,
+		policy,
+		assertFence,
+		expectedDestination,
+	);
+}
+
+function appendManagedFileStreamingSync(
+	destination: string,
+	appendedBytes: Uint8Array,
+	root: ManagedDirectoryRoot,
+	policy: ManagedSessionSecurityPolicy,
+): ManagedFileSnapshot["identity"] {
+	const predecessor = captureManagedFileIdentityStreamingNoFollow(destination);
+	replaceManagedFileGeneratedSync(
+		destination,
+		stagingFd => {
+			const sourceFd = fs.openSync(destination, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+			try {
+				const before = fs.fstatSync(sourceFd, { bigint: true });
+				if (!sameReplacementIdentity(identity(before, predecessor.sha256), predecessor))
+					throw new Error("managed_replace_identity_mismatch");
+				const hash = createHash("sha256");
+				const chunk = Buffer.alloc(64 * 1024);
+				let total = 0;
+				for (;;) {
+					const count = fs.readSync(sourceFd, chunk, 0, chunk.byteLength, null);
+					if (count === 0) break;
+					let written = 0;
+					while (written < count) {
+						const amount = fs.writeSync(stagingFd, chunk, written, count - written);
+						if (amount === 0) throw new Error("managed_replace_short_write");
+						written += amount;
+					}
+					hash.update(chunk.subarray(0, count));
+					total += count;
+				}
+				const after = fs.fstatSync(sourceFd, { bigint: true });
+				const named = fs.lstatSync(destination, { bigint: true });
+				if (
+					!sameReplacementIdentity(identity(after, predecessor.sha256), predecessor) ||
+					!sameReplacementIdentity(identity(named, predecessor.sha256), predecessor)
+				)
+					throw new Error("managed_replace_identity_mismatch");
+				if (hash.copy().digest("hex") !== predecessor.sha256) throw new Error("managed_replace_identity_mismatch");
+				let appended = 0;
+				while (appended < appendedBytes.byteLength) {
+					const amount = fs.writeSync(stagingFd, appendedBytes, appended, appendedBytes.byteLength - appended);
+					if (amount === 0) throw new Error("managed_replace_short_write");
+					hash.update(appendedBytes.subarray(appended, appended + amount));
+					appended += amount;
+				}
+				return { size: total + appended, sha256: hash.digest("hex") };
+			} finally {
+				fs.closeSync(sourceFd);
+			}
+		},
+		root,
+		policy,
+		undefined,
+		predecessor,
+	);
+	return captureManagedFileIdentityStreamingNoFollow(destination);
+}
+
 export async function replaceManagedFile(
 	destination: string,
 	bytes: Uint8Array,