@gajae-code/coding-agent 0.13.0 → 0.13.1

package/src/session/session-manager.ts

@@ -1359,9 +1359,10 @@ type BoundedLineScanFailure = "read_failed" | "oversized_line" | "unterminated"
  * path. Returns `undefined` only after every byte was consumed as a complete
  * newline-terminated line.
  */
+const boundedJsonLineDecoder = new TextDecoder("utf-8", { fatal: true });
 function decodeBoundedJsonLine(lineBytes: Uint8Array): string {
 	const length = lineBytes.at(-1) === 0x0a ? lineBytes.byteLength - 1 : lineBytes.byteLength;
-	return Buffer.from(lineBytes.buffer, lineBytes.byteOffset, length).toString("utf8");
+	return boundedJsonLineDecoder.decode(lineBytes.subarray(0, length));
 }
 
 function bytesStartWith(bytes: Uint8Array, prefix: Uint8Array): boolean {
@@ -3409,6 +3410,61 @@ function sameResumeStat(left: SessionStorageStat, right: SessionStorageStat): bo
 	);
 }
 
+function resumeIdentityMatchesDescriptor(identity: ResumeSessionIdentity, descriptor: DescriptorSnapshot): boolean {
+	return (
+		identity.dev === descriptor.dev &&
+		identity.ino === descriptor.ino &&
+		identity.nlink === descriptor.nlink &&
+		identity.size === descriptor.size &&
+		identity.mtimeNs === descriptor.mtimeNs &&
+		(identity.ctimeNs === undefined || identity.ctimeNs === descriptor.ctimeNs)
+	);
+}
+
+function descriptorSnapshotAsStorageStat(descriptor: DescriptorSnapshot): SessionStorageStat {
+	const mtimeMs = Number(descriptor.mtimeNs) / 1_000_000;
+	return { ...descriptor, mtimeMs, mtime: new Date(mtimeMs), isFile: true };
+}
+
+function retainedManagedInspectionStorage(
+	storage: SessionStorage,
+	store: ManagedSessionDescendantStore,
+	filePath: string,
+): SessionStorage {
+	const resolved = path.resolve(filePath);
+	const relative = path.basename(resolved);
+	const statExpected = (): SessionStorageStat => {
+		store.assertBound();
+		const descriptor = store.descriptorExpected(relative);
+		if (!descriptor) throw Object.assign(new Error("Managed file not found"), { code: "ENOENT" });
+		return descriptorSnapshotAsStorageStat(descriptor);
+	};
+	return new Proxy(storage, {
+		get: (target, property) => {
+			if (property === "statSync")
+				return (candidate: string) =>
+					path.resolve(candidate) === resolved ? statExpected() : target.statSync(candidate);
+			if (property === "existsSync")
+				return (candidate: string) =>
+					path.resolve(candidate) === resolved
+						? store.descriptorExpected(relative) !== null
+						: target.existsSync(candidate);
+			if (property === "readSnapshotSync")
+				return (candidate: string) => {
+					if (path.resolve(candidate) !== resolved) return target.readSnapshotSync!(candidate);
+					const before = statExpected();
+					const snapshot = store.readExpected(relative);
+					if (!snapshot) throw Object.assign(new Error("Managed file not found"), { code: "ENOENT" });
+					const after = statExpected();
+					if (!sameResumeStat(before, after)) throw new Error("source_changed");
+					return { bytes: snapshot.bytes, stat: before };
+				};
+			const value = Reflect.get(target, property, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+}
+
 interface ResumeInspectionSnapshot {
 	identity: ResumeSessionIdentity;
 	content: Uint8Array;
@@ -3688,34 +3744,40 @@ function inspectTranscriptBounded(
 	}
 
 	const hash = crypto.createHash("sha256");
-	const decoder = new TextDecoder("utf-8", { fatal: true });
-	let carry = "";
 	let sessionId: string | undefined;
 	let cwd: string | undefined;
-	try {
-		for (let offset = 0; offset < before.size; offset += TRANSCRIPT_CAPTURE_CHUNK_BYTES) {
-			const length = Math.min(TRANSCRIPT_CAPTURE_CHUNK_BYTES, before.size - offset);
-			const chunk = storage.readRangeSync(canonicalPath, offset, length).bytes;
-			hash.update(chunk);
-			const text = decoder.decode(chunk, { stream: offset + length < before.size });
-			const combined = carry + text;
-			const lines = combined.split("\n");
-			carry = lines.pop() ?? "";
-			for (const line of lines) {
-				if (line.length === 0) continue;
-				const parsed = JSON.parse(line) as SessionHeader;
+	const scanResult: { stat?: SessionStorageStat } = {};
+	const scanFailure = scanTranscriptLinesBounded(
+		storage,
+		canonicalPath,
+		before.size,
+		(_lineStart, lineBytes) => {
+			hash.update(lineBytes);
+			if (lineBytes.byteLength === 1 && lineBytes[0] === 0x0a) return;
+			try {
+				const parsed = JSON.parse(decodeBoundedJsonLine(lineBytes)) as SessionHeader;
 				if (sessionId === undefined) {
-					if (parsed.type !== "session" || typeof parsed.id !== "string")
-						return { ok: false, error: { kind: "error", reason: "malformed" } };
+					if (parsed.type !== "session" || typeof parsed.id !== "string") return false;
 					sessionId = parsed.id;
 					cwd = typeof parsed.cwd === "string" ? parsed.cwd : undefined;
 				}
+				return;
+			} catch {
+				return false;
 			}
-			if (((offset + length) & (8 * 1024 * 1024 - 1)) === 0) Bun.gc(true);
-		}
-	} catch {
-		return { ok: false, error: { kind: "error", reason: "malformed" } };
+		},
+		scanResult,
+		true,
+		true,
+	);
+	if (scanFailure) {
+		return {
+			ok: false,
+			error: { kind: "error", reason: scanFailure === "read_failed" ? "read-failed" : "malformed" },
+		};
 	}
+	if (scanResult.stat && !sameResumeStat(before, scanResult.stat))
+		return { ok: false, error: { kind: "error", reason: "unstable" } };
 	if (sessionId === undefined) return { ok: false, error: { kind: "error", reason: "malformed" } };
 
 	let after: SessionStorageStat;
@@ -6766,11 +6828,15 @@ export class SessionManager {
 	#managedTranscriptStoreCache: { directory: string; store: ManagedSessionDescendantStore } | null = null;
 	#ownedManagedAuthority: ManagedSessionDescendantStore | undefined;
 	#managedSidecarCacheStore: EphemeralBlobStore | undefined;
+	readonly #managedSidecarCleanupStores = new Set<EphemeralBlobStore>();
 	#managedSidecarAuthorityStore: ManagedSessionDescendantStore | undefined;
 	#managedSidecarSecurityContext: ManagedSessionSecurityContext | undefined;
 	#managedSidecarCacheSessionFile: string | undefined;
 	#managedRangeExpectedDescriptor: DescriptorSnapshot | undefined;
 	#boundedReadStorageProxy: SessionStorage | undefined;
+	#boundedManagedSource:
+		| { path: string; store: ManagedSessionDescendantStore; descriptor: DescriptorSnapshot; owned: boolean }
+		| undefined;
 	// When set, take precedence over the lazily-derived per-session manager.
 	// Subagents adopt the parent's manager so artifact IDs are unique across the
 	// whole agent tree and all files land in the parent's artifacts dir.
@@ -7515,6 +7581,7 @@ export class SessionManager {
 		this.#titleSource = state.header.titleSource;
 		this.#sessionFile = state.sessionFile;
 		this.#managedRangeExpectedDescriptor = undefined;
+		this.#clearBoundedManagedSource();
 		this.#flushed = false;
 		this.#needsFullRewriteOnNextPersist = false;
 		this.#ensuredOnDisk = false;
@@ -8289,6 +8356,7 @@ export class SessionManager {
 		const runtime = this.#sidecarRuntime;
 		if (!runtime?.indexPath || !runtime.tailPath) return undefined;
 		const telemetry = this.#firstOpenTelemetry;
+		const boundedReadStorage = this.#boundedReadStorage();
 		let tailWriter: SessionStorageWriter | undefined;
 		let buildFailed = false;
 		const secondaryArtifactsEligible =
@@ -8401,11 +8469,14 @@ export class SessionManager {
 			let hashOffset = checkpoint.offset;
 			while (hashOffset < baseEndOffset) {
 				const length = Math.min(SESSION_RANGE_READ_MAX_BYTES, baseEndOffset - hashOffset);
-				const bytes = this.#storage.readRangeSync!(sessionFile, hashOffset, length).bytes;
-				if (bytes.byteLength !== length) {
-					this.#lazyReopenFallbackReason = "bounded_scan_build_failed";
+				const baseSnapshot = boundedReadStorage.readRangeSync!(sessionFile, hashOffset, length);
+				if (!sameDescriptor(descriptor, baseSnapshot.stat) || baseSnapshot.bytes.byteLength !== length) {
+					this.#lazyReopenFallbackReason = !sameDescriptor(descriptor, baseSnapshot.stat)
+						? "bounded_first_open_descriptor_changed"
+						: "bounded_scan_build_failed";
 					return undefined;
 				}
+				const bytes = baseSnapshot.bytes;
 				baseHash.update(bytes);
 				telemetry.bytesRead += length;
 				telemetry.transcriptBytesRead += length;
@@ -8417,7 +8488,7 @@ export class SessionManager {
 				this.#lazyReopenFallbackReason = "bounded_scan_budget";
 				return undefined;
 			}
-			const suffixSnapshot = this.#storage.readRangeSync!(sessionFile, baseEndOffset, suffixLength);
+			const suffixSnapshot = boundedReadStorage.readRangeSync!(sessionFile, baseEndOffset, suffixLength);
 			if (!sameDescriptor(descriptor, suffixSnapshot.stat) || suffixSnapshot.bytes.byteLength !== suffixLength) {
 				this.#lazyReopenFallbackReason = "bounded_first_open_descriptor_changed";
 				return undefined;
@@ -9375,6 +9446,7 @@ export class SessionManager {
 		this.#sidecarRuntime = undefined;
 		this.#releaseManagedSidecarCache();
 		this.#boundedReadStorageProxy = undefined;
+		this.#clearBoundedManagedSource();
 		if (!this.#lifecycleIdAdopted && stage.sessionId === lifecyclePreallocatedSessionId())
 			this.#lifecycleIdAdopted = true;
 		this.#persistChain = Promise.resolve();
@@ -9540,6 +9612,21 @@ export class SessionManager {
 			throw new Error("Uncommitted session discard is limited to this manager's configured session directory.");
 		}
 		try {
+			if (this.destination.kind === "managed") {
+				const store = this.#managedTranscriptStore(canonicalCandidate);
+				const transcriptName = path.basename(canonicalCandidate);
+				const artifactName = path.basename(canonicalCandidate.slice(0, -6));
+				const transcript = store.readExpected(transcriptName);
+				let artifacts: native.NativeDirectoryTreeSnapshot | undefined;
+				try {
+					artifacts = store.captureTree(artifactName);
+				} catch (error) {
+					if (!(error instanceof Error) || error.message !== "not_found") throw error;
+				}
+				if (artifacts) store.removeTreeExpected(artifactName, artifacts);
+				if (transcript) store.removeExpected(transcriptName, transcript);
+				return;
+			}
 			await this.#storage.deleteSessionWithArtifacts(canonicalCandidate);
 		} catch (err) {
 			if (isEnoent(err)) return;
@@ -10681,12 +10768,23 @@ export class SessionManager {
 	#releaseManagedSidecarCache(): void {
 		this.#managedSidecarAuthorityStore?.close();
 		this.#managedSidecarSecurityContext?.retainedAuthority?.close();
+		const store = this.#managedSidecarCacheStore;
 		this.#managedSidecarAuthorityStore = undefined;
 		this.#managedSidecarSecurityContext = undefined;
-		this.#managedSidecarCacheStore?.dispose();
 		this.#managedSidecarCacheStore = undefined;
 		this.#managedSidecarCacheSessionFile = undefined;
 		this.#managedRangeExpectedDescriptor = undefined;
+		if (store) this.#managedSidecarCleanupStores.add(store);
+		for (const pending of this.#managedSidecarCleanupStores) {
+			try {
+				pending.dispose();
+				this.#managedSidecarCleanupStores.delete(pending);
+			} catch (error) {
+				const candidate = error instanceof ResidentCacheTrustError ? error.reason : "";
+				const reason = /^[a-z0-9_]{1,64}$/.test(candidate) ? candidate : "cleanup_failed";
+				logger.warn("Failed to dispose the managed sidecar resident cache; retained for retry", { reason });
+			}
+		}
 	}
 
 	#isManagedSidecarPath(candidate: string): boolean {
@@ -10742,7 +10840,25 @@ export class SessionManager {
 		return instanceDir;
 	}
 
+	#clearBoundedManagedSource(): void {
+		const source = this.#boundedManagedSource;
+		this.#boundedManagedSource = undefined;
+		if (source?.owned) source.store.close();
+	}
 	#readRangeSync(filePath: string, start: number, length: number): SessionStorageRangeSnapshot {
+		const boundedManagedSource = this.#boundedManagedSource;
+		if (
+			this.destination.kind === "managed" &&
+			boundedManagedSource &&
+			path.resolve(filePath) === path.resolve(boundedManagedSource.path)
+		) {
+			return boundedManagedSource.store.readRangeExpectedSync(
+				path.basename(filePath),
+				start,
+				length,
+				boundedManagedSource.descriptor,
+			);
+		}
 		if (
 			this.destination.kind === "managed" &&
 			this.#sessionFile &&
@@ -10770,6 +10886,17 @@ export class SessionManager {
 	}
 
 	#statSync(filePath: string): SessionStorageStat {
+		const boundedManagedSource = this.#boundedManagedSource;
+		if (
+			this.destination.kind === "managed" &&
+			boundedManagedSource &&
+			path.resolve(filePath) === path.resolve(boundedManagedSource.path)
+		) {
+			const descriptor = boundedManagedSource.store.descriptorExpected(path.basename(filePath));
+			if (!descriptor || !sameDescriptor(boundedManagedSource.descriptor, descriptor))
+				throw new Error("source_changed");
+			return descriptor;
+		}
 		if (
 			this.destination.kind === "managed" &&
 			this.#sessionFile &&
@@ -14504,6 +14631,7 @@ export class SessionManager {
 		this.#labelsById.clear();
 		this.#resetMaterializedCaches();
 		this.#releaseManagedSidecarCache();
+		this.#clearBoundedManagedSource();
 	}
 
 	/** Close the persistent writer after flushing all pending data. */
@@ -17565,10 +17693,11 @@ export class SessionManager {
 	}
 
 	async #tryForkFromBoundedSource(sourcePath: string, expectedIdentity?: ResumeSessionIdentity): Promise<boolean> {
-		const sourceSize = expectedIdentity?.size ?? this.#storage.statSync(sourcePath).size;
+		const boundedReadStorage = this.#boundedReadStorage();
+		const sourceSize = expectedIdentity?.size ?? boundedReadStorage.statSync(sourcePath).size;
 		if (
 			this.#effectiveSessionMemoryMode(sourceSize) !== "enabled" ||
-			typeof this.#storage.readRangeSync !== "function" ||
+			typeof boundedReadStorage.readRangeSync !== "function" ||
 			typeof this.#storage.openStagedWriter !== "function"
 		)
 			return false;
@@ -17584,7 +17713,7 @@ export class SessionManager {
 		const preflightHash = crypto.createHash("sha256");
 		const preflightResult: { stat?: SessionStorageStat } = {};
 		const preflightFailure = scanTranscriptLinesBounded(
-			this.#storage,
+			boundedReadStorage,
 			sourcePath,
 			sourceSize,
 			(_offset, lineBytes) => {
@@ -17681,7 +17810,7 @@ export class SessionManager {
 			const copyHash = crypto.createHash("sha256");
 			const copyResult: { stat?: SessionStorageStat } = {};
 			const copyFailure = scanTranscriptLinesBounded(
-				this.#storage,
+				boundedReadStorage,
 				sourcePath,
 				identity.size,
 				(_offset, lineBytes) => {
@@ -17732,16 +17861,20 @@ export class SessionManager {
 				if (!managedPublishedTranscript) throw new Error("managed_fork_transcript_publish_missing");
 			}
 			if (copyResult.stat) {
-				const current = this.#storage.statSync(sourcePath);
+				const current = boundedReadStorage.statSync(sourcePath);
 				if (!sameDescriptor(copyResult.stat, current)) throw new Error("fork_source_identity_changed");
-			} else if (revalidateTranscriptIdentityBounded(sourcePath, this.#storage, identity).kind !== "valid") {
+			} else if (revalidateTranscriptIdentityBounded(sourcePath, boundedReadStorage, identity).kind !== "valid") {
 				throw new Error("fork_source_identity_changed");
 			}
 			await this.copyArtifactsForFork(sourcePath, fresh.sessionFile);
-			if (this.destination.kind === "managed" && this.#storage.existsSync(fresh.sessionFile.slice(0, -6)))
-				managedPublishedArtifacts = this.#managedTranscriptStore(fresh.sessionFile).captureTree(
-					path.basename(fresh.sessionFile.slice(0, -6)),
-				);
+			if (this.destination.kind === "managed") {
+				const store = this.#managedTranscriptStore(fresh.sessionFile);
+				try {
+					managedPublishedArtifacts = store.captureTree(path.basename(fresh.sessionFile.slice(0, -6)));
+				} catch (error) {
+					if (!(error instanceof Error) || error.message !== "not_found") throw error;
+				}
+			}
 			await this.#initSessionFile(fresh.sessionFile);
 			writeTerminalBreadcrumb(this.cwd, fresh.sessionFile);
 			return true;
@@ -17779,8 +17912,40 @@ export class SessionManager {
 		const entryPatches = new Map<string, EntryPatchRecord["patch"]>();
 		let overlayBytes = 0;
 		let requiresRecordTransforms = false;
+		const managedSourceStorage = this.#boundedManagedSource ? this.#boundedReadStorage() : undefined;
+		const forEachSourceLine = (visit: (line: Uint8Array) => boolean | undefined): void => {
+			if (!managedSourceStorage) {
+				snapshot.forEachLine(visit);
+				return;
+			}
+			const hash = crypto.createHash("sha256");
+			const scanResult: { stat?: SessionStorageStat } = {};
+			let aborted = false;
+			const failure = scanTranscriptLinesBounded(
+				managedSourceStorage,
+				snapshot.sourcePath,
+				snapshot.identity.size,
+				(_offset, line) => {
+					hash.update(line);
+					const body = line[line.byteLength - 1] === 0x0a ? line.subarray(0, line.byteLength - 1) : line;
+					if (body.byteLength === 0) return;
+					if (visit(body) === false) {
+						aborted = true;
+						return false;
+					}
+				},
+				scanResult,
+				true,
+				true,
+			);
+			if (failure && !(failure === "aborted" && aborted)) throw new Error(`transcript_scan_${failure}`);
+			if (aborted) return;
+			const terminalStat = scanResult.stat ?? managedSourceStorage.statSync(snapshot.sourcePath);
+			if (!resumeIdentityMatchesDescriptor(snapshot.identity, terminalStat)) throw new Error("identity-mismatch");
+			if (hash.digest("hex") !== snapshot.identity.sha256) throw new Error("identity-mismatch");
+		};
 		try {
-			snapshot.forEachLine(line => {
+			forEachSourceLine(line => {
 				if (rejected || line.byteLength === 0) return;
 				const record = JSON.parse(decodeBoundedJsonLine(line)) as FileEntry | SessionPatchRecord;
 				if (ordinal++ === 0) {
@@ -17841,7 +18006,7 @@ export class SessionManager {
 		let managedPublishedTranscript: ManagedFileSnapshot | undefined;
 		try {
 			let writeOrdinal = 0;
-			snapshot.forEachLine(line => {
+			forEachSourceLine(line => {
 				if (line.byteLength === 0) return;
 				if (writeOrdinal++ === 0) {
 					staged.writeLine(Buffer.from(JSON.stringify(fresh.header), "utf8"));
@@ -17872,9 +18037,13 @@ export class SessionManager {
 					undefined;
 				if (!managedPublishedTranscript) throw new Error("managed_fork_transcript_publish_missing");
 			}
-			const copyDescriptor = snapshot.getLastReadStat();
-			if (snapshot.storage instanceof FileSessionStorage && copyDescriptor) {
-				const current = snapshot.storage.statSync(snapshot.sourcePath);
+			const copyDescriptor = managedSourceStorage
+				? managedSourceStorage.statSync(snapshot.sourcePath)
+				: snapshot.getLastReadStat();
+			if (copyDescriptor) {
+				const current = managedSourceStorage
+					? managedSourceStorage.statSync(snapshot.sourcePath)
+					: snapshot.storage.statSync(snapshot.sourcePath);
 				if (!sameDescriptor(copyDescriptor, current)) {
 					await this.#cleanupFailedForkDestination(fresh.sessionFile, managedPublishedTranscript);
 					return { kind: "error", reason: "identity-mismatch" };
@@ -17913,27 +18082,71 @@ export class SessionManager {
 		sessionMemoryMode: SessionMemoryMode = "shadow",
 	): Promise<SessionManager> {
 		const destination = destinationFor(cwd, destinationInput, storage);
-		let managedSourcePath = sourcePath;
-		if (destination.kind === "managed" && storage instanceof FileSessionStorage) {
-			const prepared = await SessionManager.prepareManagedCandidateForWrite(
-				sourcePath,
-				migrationPolicy,
-				destination,
-			);
-			managedSourcePath = storage.existsSync(prepared) ? prepared : sourcePath;
-		}
 		const dir = destination.directory;
 		const manager = new SessionManager(cwd, dir, true, storage, destination);
 		manager.#sessionMemoryMode = sessionMemoryMode;
-		const sourceSize = storage.statSync(managedSourcePath).size;
-		if (manager.#effectiveSessionMemoryMode(sourceSize) === "enabled") {
-			const inspected = inspectTranscriptBounded(managedSourcePath, storage, BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES);
+		let managedSourcePath = sourcePath;
+		if (destination.kind === "managed" && storage instanceof FileSessionStorage) {
+			const resolvedSource = path.resolve(sourcePath);
+			const sessionsRoot = path.resolve(destination.securityContext.sessionsRoot);
 			if (
-				inspected.ok &&
-				(await manager.#tryForkFromBoundedSource(managedSourcePath, inspected.inspection.identity))
-			)
-				return manager;
+				pathIsWithin(sessionsRoot, resolvedSource) &&
+				path.dirname(resolvedSource) !== path.resolve(destination.directory)
+			) {
+				managedSourcePath = await SessionManager.prepareManagedCandidateForWrite(
+					sourcePath,
+					migrationPolicy,
+					destination,
+				);
+			}
+		}
+		let boundedStorage: SessionStorage = storage;
+		if (
+			destination.kind === "managed" &&
+			storage instanceof FileSessionStorage &&
+			pathIsWithin(path.resolve(destination.securityContext.sessionsRoot), path.resolve(managedSourcePath))
+		) {
+			const sourceDirectory = path.dirname(path.resolve(managedSourcePath));
+			const destinationDirectory = path.resolve(destination.directory);
+			const sourceStore =
+				sourceDirectory === destinationDirectory
+					? manager.#managedTranscriptStore(managedSourcePath)
+					: managedStoreFromContext(destination.securityContext, sourceDirectory);
+			try {
+				sourceStore.assertBound();
+				const descriptor = sourceStore.descriptorExpected(path.basename(managedSourcePath));
+				if (!descriptor) throw Object.assign(new Error("Managed file not found"), { code: "ENOENT" });
+				manager.#boundedManagedSource = {
+					path: managedSourcePath,
+					store: sourceStore,
+					descriptor,
+					owned: sourceDirectory !== destinationDirectory,
+				};
+				boundedStorage = manager.#boundedReadStorage();
+			} catch (error) {
+				sourceStore.close();
+				throw error;
+			}
 		}
+		let sourceSize: number | undefined;
+		try {
+			sourceSize = boundedStorage.statSync(managedSourcePath).size;
+			if (manager.#effectiveSessionMemoryMode(sourceSize) === "enabled") {
+				const inspected = inspectTranscriptBounded(
+					managedSourcePath,
+					boundedStorage,
+					BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES,
+				);
+				if (
+					inspected.ok &&
+					(await manager.#tryForkFromBoundedSource(managedSourcePath, inspected.inspection.identity))
+				)
+					return manager;
+			}
+		} finally {
+			manager.#clearBoundedManagedSource();
+		}
+		if (sourceSize === undefined) throw new Error("Managed source size unavailable");
 		if (sourceSize > eagerHydrationMaxBytes()) throw new SessionTranscriptOversizedError(sourceSize);
 		const forkEntries = await loadEntriesFromFile(managedSourcePath, storage);
 		migrateToCurrentVersion(forkEntries);
@@ -17997,6 +18210,12 @@ export class SessionManager {
 					process.platform !== "win32" &&
 					sourceSize !== undefined &&
 					sourceSize >= autoModeMinTranscriptBytes());
+			let strictSmallInspection: ResumeInspectionSnapshot | undefined;
+			if (boundedAdmission && sourceSize !== undefined && sourceSize <= eagerHydrationMaxBytes()) {
+				const strict = inspectResumeSessionFile(filePath, storage);
+				if ("kind" in strict) throw new Error(`Could not open session: ${strict.reason}`);
+				strictSmallInspection = strict;
+			}
 			if (!boundedAdmission) {
 				const inspected = inspectResumeSessionFile(filePath, storage);
 				if ("kind" in inspected) {
@@ -18029,7 +18248,9 @@ export class SessionManager {
 				manager.buildSessionContext();
 				return manager;
 			}
-			const inspected = inspectTranscriptHeaderBounded(filePath, storage, BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES);
+			const inspected = strictSmallInspection
+				? { ok: true as const, inspection: { cwd: (strictSmallInspection.entries[0] as SessionHeader).cwd } }
+				: inspectTranscriptHeaderBounded(filePath, storage, BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES);
 			if (!inspected.ok) {
 				if (inspected.error.reason === "missing") {
 					const manager = new SessionManager(getProjectDir(), destination.directory, true, storage, destination);
@@ -18050,23 +18271,72 @@ export class SessionManager {
 			);
 			manager.#sessionMemoryMode = sessionMemoryMode;
 			await manager.#initSessionFile(filePath);
+			if (strictSmallInspection) {
+				const revalidated = revalidateTranscriptIdentityBounded(filePath, storage, strictSmallInspection.identity);
+				if (revalidated.kind !== "valid" || manager.#sessionId !== strictSmallInspection.identity.sessionId) {
+					manager.setSessionMemoryMode("off");
+					await manager.close();
+					throw new Error("Could not open session: unstable");
+				}
+			}
 			manager.buildSessionContext();
 			return manager;
 		}
-		let managedResumeBounded = sessionMemoryMode === "enabled";
-		if (sessionMemoryMode === "auto" && process.platform !== "win32") {
+		const sameManagedDirectory = path.dirname(path.resolve(filePath)) === path.resolve(destination.directory);
+		let managedInspectionStore: ManagedSessionDescendantStore | undefined;
+		let managedInspectionStorage: SessionStorage = storage;
+		if (sameManagedDirectory) {
+			managedInspectionStore = managedStoreFromContext(destination.securityContext, destination.directory);
+			managedInspectionStorage = retainedManagedInspectionStorage(storage, managedInspectionStore, filePath);
+		}
+		let managedSourceSize: number | undefined;
+		try {
+			managedSourceSize = managedInspectionStorage.statSync(filePath).size;
+		} catch {
+			// Strict inspection below reports the stable failure.
+		}
+		const managedResumeBounded =
+			sessionMemoryMode === "enabled" ||
+			(sessionMemoryMode === "auto" &&
+				process.platform !== "win32" &&
+				managedSourceSize !== undefined &&
+				managedSourceSize >= autoModeMinTranscriptBytes());
+		let strictManagedSmallInspection: ResumeInspectionSnapshot | undefined;
+		if (
+			managedResumeBounded &&
+			managedSourceSize !== undefined &&
+			managedSourceSize <= eagerHydrationMaxBytes() &&
+			sameManagedDirectory
+		) {
 			try {
-				managedResumeBounded = storage.statSync(filePath).size >= autoModeMinTranscriptBytes();
-			} catch {
-				managedResumeBounded = false;
+				const strict = inspectResumeSessionFile(filePath, managedInspectionStorage);
+				if ("kind" in strict) throw new Error(`Could not open session: ${strict.reason}`);
+				strictManagedSmallInspection = strict;
+			} catch (error) {
+				managedInspectionStore?.close();
+				throw error;
 			}
 		}
 
-		if (managedResumeBounded && path.dirname(path.resolve(filePath)) === path.resolve(destination.directory)) {
+		if (managedResumeBounded && sameManagedDirectory) {
 			const manager = new SessionManager(getProjectDir(), destination.directory, true, storage, destination);
 			manager.#sessionMemoryMode = sessionMemoryMode;
 			try {
 				await manager.#initSessionFile(filePath, true);
+				if (strictManagedSmallInspection) {
+					const revalidated = revalidateTranscriptIdentityBounded(
+						filePath,
+						managedInspectionStorage,
+						strictManagedSmallInspection.identity,
+					);
+					if (
+						revalidated.kind !== "valid" ||
+						manager.#sessionId !== strictManagedSmallInspection.identity.sessionId
+					) {
+						manager.setSessionMemoryMode("off");
+						throw new Error("Could not open session: unstable");
+					}
+				}
 				const header = manager.#fileEntries.find(entry => entry.type === "session") as SessionHeader | undefined;
 				if (header?.cwd) manager.cwd = header.cwd;
 				manager.buildSessionContext();
@@ -18074,8 +18344,12 @@ export class SessionManager {
 			} catch (error) {
 				await manager.close().catch(() => {});
 				throw error;
+			} finally {
+				managedInspectionStore?.close();
 			}
 		}
+		managedInspectionStore?.close();
+		managedInspectionStore = undefined;
 		const inspected = inspectResumeSessionFile(filePath, storage);
 		if ("kind" in inspected) {
 			if (inspected.reason === "missing") {
@@ -18132,6 +18406,7 @@ export class SessionManager {
 		const boundedAdmission =
 			sessionMemoryMode === "enabled" ||
 			(sessionMemoryMode === "auto" &&
+				process.platform !== "win32" &&
 				capturedDescriptor !== null &&
 				capturedDescriptor.size >= autoModeMinTranscriptBytes());
 		if (boundedAdmission && capturedDescriptor && capturedDescriptor.size > 0) {
@@ -18300,25 +18575,25 @@ export class SessionManager {
 	/** Delete an authorized managed or project-local picker candidate. */
 	static async deleteManagedCandidate(sessionPath: string): Promise<void> {
 		const storage = new FileSessionStorage();
-		const entries = await loadEntriesFromFile(sessionPath, storage);
-		const header = entries.find(entry => entry.type === "session") as SessionHeader | undefined;
-		if (!header?.cwd) throw new Error("Session has no valid workspace header.");
-		const projectGjcDir = path.join(path.resolve(header.cwd), ".gjc");
+		const inspected = inspectTranscriptHeaderBounded(sessionPath, storage, BOUNDED_RESUME_TRANSCRIPT_MAX_BYTES);
+		if (!inspected.ok || !inspected.inspection.cwd) throw new Error("Session has no valid workspace header.");
+		const headerCwd = inspected.inspection.cwd;
+		const projectGjcDir = path.join(path.resolve(headerCwd), ".gjc");
 		if (isProjectSessionTranscriptPath(projectGjcDir, sessionPath)) {
 			const relativePath = path.relative(projectGjcDir, path.resolve(sessionPath)).split(path.sep).join("/");
 			const authority = nativeSessionManager().openRecoveryFsRoot(projectGjcDir);
 			try {
-				const captured = authority.readManaged(relativePath);
-				if (!captured.ok || !captured.identity || !captured.data || !captured.identity.sha256)
+				const observed = authority.stat(relativePath);
+				if (!observed.ok || !observed.identity?.sha256)
 					throw new Error("Project session is no longer an authorized candidate.");
 				const removed = authority.removeManaged(
 					relativePath,
-					captured.identity.dev,
-					captured.identity.ino,
-					captured.identity.size,
-					captured.identity.mtimeNs,
-					captured.identity.ctimeNs,
-					captured.identity.sha256,
+					observed.identity.dev,
+					observed.identity.ino,
+					observed.identity.size,
+					observed.identity.mtimeNs,
+					observed.identity.ctimeNs,
+					observed.identity.sha256,
 				);
 				if (!removed.ok) throw new Error(removed.code ?? "Could not delete project session.");
 				return;
@@ -18328,7 +18603,7 @@ export class SessionManager {
 		}
 		const sessionsRoot = path.resolve(sessionPath, "../..");
 		const resolved = resolveManagedScope({
-			cwd: header.cwd,
+			cwd: headerCwd,
 			agentDir: path.resolve(sessionsRoot, ".."),
 			sessionsRoot,
 		});
@@ -18375,8 +18650,48 @@ export class SessionManager {
 		) {
 			const boundedManager = new SessionManager(cwd, destination.directory, true, snapshot.storage, destination);
 			boundedManager.#sessionMemoryMode = sessionMemoryMode;
-			const bounded = await boundedManager.#tryForkFromCapturedBounded(snapshot);
-			if (bounded) return bounded;
+			if (
+				destination.kind === "managed" &&
+				snapshot.storage instanceof FileSessionStorage &&
+				pathIsWithin(path.resolve(destination.securityContext.sessionsRoot), path.resolve(snapshot.sourcePath))
+			) {
+				const sourceDirectory = path.dirname(path.resolve(snapshot.sourcePath));
+				const destinationDirectory = path.resolve(destination.directory);
+				const sourceStore =
+					sourceDirectory === destinationDirectory
+						? boundedManager.#managedTranscriptStore(snapshot.sourcePath)
+						: managedStoreFromContext(destination.securityContext, sourceDirectory);
+				try {
+					sourceStore.assertBound();
+					const sourceDescriptor = sourceStore.descriptorExpected(path.basename(snapshot.sourcePath));
+					if (!sourceDescriptor || !resumeIdentityMatchesDescriptor(snapshot.identity, sourceDescriptor))
+						throw new Error("identity-mismatch");
+					boundedManager.#boundedManagedSource = {
+						path: snapshot.sourcePath,
+						store: sourceStore,
+						descriptor: sourceDescriptor,
+						owned: sourceDirectory !== destinationDirectory,
+					};
+				} catch (error) {
+					sourceStore.close();
+					await boundedManager.close().catch(() => {});
+					if (toError(error).message === "identity-mismatch")
+						return { kind: "error", reason: "identity-mismatch" };
+					throw error;
+				}
+			}
+			let bounded: StrictSessionForkResult | undefined;
+			try {
+				bounded = await boundedManager.#tryForkFromCapturedBounded(snapshot);
+			} catch (error) {
+				boundedManager.#clearBoundedManagedSource();
+				await boundedManager.close().catch(() => {});
+				throw error;
+			}
+			if (bounded) {
+				boundedManager.#clearBoundedManagedSource();
+				return bounded;
+			}
 			await boundedManager.close();
 		}
 		if (snapshot.identity.size > eagerHydrationMaxBytes())
@@ -18902,6 +19217,7 @@ export class SessionManager {
 			this.#sidecarRuntime = undefined;
 			this.#releaseManagedSidecarCache();
 			this.#boundedReadStorageProxy = undefined;
+			this.#clearBoundedManagedSource();
 			throw error;
 		}
 		this.#sessionFile = promotionPath;
@@ -18993,6 +19309,17 @@ export class SessionManager {
 			} catch {
 				// The strict read-only inspection below reports the stable failure.
 			}
+			let openPath = selectedPath;
+			if (
+				destination.kind === "managed" &&
+				storage instanceof FileSessionStorage &&
+				selectedSize !== undefined &&
+				selectedSize > eagerHydrationMaxBytes() &&
+				path.dirname(path.resolve(selectedPath)) !== path.resolve(destination.directory) &&
+				pathIsWithin(path.resolve(destination.securityContext.sessionsRoot), path.resolve(selectedPath))
+			) {
+				openPath = await SessionManager.prepareManagedCandidateForWrite(selectedPath, migrationPolicy, destination);
+			}
 			const boundedSelected =
 				selectedSize !== undefined &&
 				selectedSize > eagerHydrationMaxBytes() &&
@@ -19003,7 +19330,7 @@ export class SessionManager {
 						selectedSize >= autoModeMinTranscriptBytes()));
 			if (boundedSelected) {
 				const manager = await SessionManager.open(
-					selectedPath,
+					openPath,
 					destination,
 					storage,
 					migrationPolicy,
@@ -19013,7 +19340,7 @@ export class SessionManager {
 				await manager.close();
 				return undefined;
 			}
-			const inspected = await SessionManager.inspectSessionTailReadOnly(selectedPath, storage);
+			const inspected = await SessionManager.inspectSessionTailReadOnly(openPath, storage);
 			if (inspected.kind === "error") {
 				if (inspected.reason === "oversized") throw new SessionTranscriptOversizedError(inspected.size ?? 0);
 				if (inspected.reason === "context_too_large") throw new SessionContextTooLargeError(inspected.size ?? 0);