@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/session/internal/native-publish-outcome.ts

@@ -48,6 +48,7 @@ export type NativePublishIdentity = {
 	readonly dev: string;
 	readonly ino: string;
 	readonly size: string;
+	readonly nlink?: string;
 	readonly mtimeNs: string;
 	readonly ctimeNs: string;
 	readonly sha256?: string;
@@ -126,12 +127,13 @@ const malformed: NativePublishOutcome = Object.freeze({
 
 function validIdentity(value: unknown): boolean {
 	if (value === undefined) return true;
-	if (!ownPlainRecord(value) || !exactKeys(value, ["dev", "ino", "size", "mtimeNs", "ctimeNs", "sha256"]))
+	if (!ownPlainRecord(value) || !exactKeys(value, ["dev", "ino", "nlink", "size", "mtimeNs", "ctimeNs", "sha256"]))
 		return false;
 	const decimal = (field: unknown) => typeof field === "string" && /^-?[0-9]{1,32}$/.test(field);
 	return (
 		decimal(value.dev) &&
 		decimal(value.ino) &&
+		(value.nlink === undefined || decimal(value.nlink)) &&
 		decimal(value.size) &&
 		decimal(value.mtimeNs) &&
 		decimal(value.ctimeNs) &&

package/src/session/internal/session-open-errors.ts

@@ -0,0 +1,11 @@
+export const SESSION_MIGRATION_BUSY_MESSAGE =
+	"Another session migration is still active. Wait for it to finish, then retry.";
+
+export class SessionMigrationBusyError extends Error {
+	readonly code = "migration_busy";
+
+	constructor() {
+		super(SESSION_MIGRATION_BUSY_MESSAGE);
+		this.name = "SessionMigrationBusyError";
+	}
+}

package/src/session/messages.ts

@@ -194,39 +194,14 @@ function utf8Suffix(text: string, maxBytes: number): string {
  * next provider context is constructed. Byte boundaries never split UTF-8
  * code points, so head/tail recovery remains readable for emoji and CJK text.
  */
-export function createPreAdmissionArtifactSpillPreview(
-	fullText: string,
-	artifactId: string,
-	digest: string,
-	options: { maxInlineBytes?: number; fullOutput?: boolean } = {},
-): string {
+export function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): string {
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
-	const maxInlineBytes = options.maxInlineBytes;
-	const referenceKind = options.fullOutput === false ? "retained output" : "full output";
-	let headBudget = PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES;
-	let tailBudget = PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES;
-	if (maxInlineBytes !== undefined) {
-		const receiptReserve = Buffer.byteLength(
-			`\n\n[${totalBytes} bytes omitted; sha256:${digest}; ${referenceKind}: artifact://${artifactId}]\n\n`,
-			"utf-8",
-		);
-		const contentBudget = Math.max(0, maxInlineBytes - receiptReserve);
-		headBudget = Math.min(headBudget, Math.ceil(contentBudget / 2));
-		tailBudget = Math.min(tailBudget, Math.floor(contentBudget / 2));
-	}
-	for (;;) {
-		const head = utf8Prefix(fullText, headBudget);
-		const tail = utf8Suffix(fullText, tailBudget);
-		const retainedBytes = Buffer.byteLength(head, "utf-8") + Buffer.byteLength(tail, "utf-8");
-		const omittedBytes = Math.max(0, totalBytes - retainedBytes);
-		const receipt = `[${omittedBytes} bytes omitted; sha256:${digest}; ${referenceKind}: artifact://${artifactId}]`;
-		const preview = `${head}\n\n${receipt}\n\n${tail}`;
-		if (maxInlineBytes === undefined || Buffer.byteLength(preview, "utf-8") <= maxInlineBytes) return preview;
-		if (headBudget === 0 && tailBudget === 0) return utf8Prefix(receipt, maxInlineBytes);
-		const overflow = Buffer.byteLength(preview, "utf-8") - maxInlineBytes;
-		if (tailBudget >= headBudget) tailBudget = Math.max(0, tailBudget - overflow);
-		else headBudget = Math.max(0, headBudget - overflow);
-	}
+	const head = utf8Prefix(fullText, PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES);
+	const tail = utf8Suffix(fullText, PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES);
+	const retainedBytes = Buffer.byteLength(head, "utf-8") + Buffer.byteLength(tail, "utf-8");
+	const omittedBytes = Math.max(0, totalBytes - retainedBytes);
+	const receipt = `[${omittedBytes} bytes omitted; sha256:${digest}; full output: artifact://${artifactId}]`;
+	return `${head}\n\n${receipt}\n\n${tail}`;
 }
 
 /**

package/src/session/session-manager.ts

@@ -37,7 +37,7 @@ import { assertSafePathComponent } from "../gjc-runtime/session-layout";
 import { writeTextAtomic } from "../gjc-runtime/state-writer";
 import type { ManagedLegacyLocalMigrationSource } from "../internal-urls/local-protocol";
 import * as git from "../utils/git";
-import { ArtifactManager, type ArtifactSaveReceipt } from "./artifacts";
+import { ArtifactManager } from "./artifacts";
 import {
 	type BlobPutResult,
 	BlobStore,
@@ -83,8 +83,8 @@ import {
 	mayCleanManagedTreeStaging,
 	retainManagedDirectoryAuthority,
 } from "./internal/managed-session-storage";
-
 import { classifyNativePublishOutcome, formatNativePublishDiagnostic } from "./internal/native-publish-outcome";
+import { SessionMigrationBusyError } from "./internal/session-open-errors";
 import {
 	hasOnlyKeys as hasOnlyMemoryGuardKeys,
 	isMemoryGuardDecimalString,
@@ -940,6 +940,8 @@ export class SessionMigrationPolicyError extends Error {
 }
 
 export class SessionArtifactCapacityError extends Error {
+	readonly code = "artifact_capacity_exceeded";
+
 	constructor(message: string) {
 		super(message);
 		this.name = "SessionArtifactCapacityError";
@@ -954,7 +956,12 @@ export interface StrictSessionOpenSuccess {
 
 export interface StrictSessionOpenFailure {
 	kind: "error";
-	reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required" | "artifact_capacity_exceeded";
+	reason:
+		| ResumeTailError["reason"]
+		| "identity-mismatch"
+		| "migration-required"
+		| "artifact_capacity_exceeded"
+		| "migration_busy";
 	message?: string;
 }
 
@@ -1133,7 +1140,7 @@ export function createReadonlySessionManager(manager: SessionManager): ReadonlyS
 
 /** Internal artifact-writing capability. Read-only facades expose it only through a private weak-map lookup. */
 export type SessionArtifactCapability = Readonly<
-	Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "putBlob">
+	Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "putBlob">
 >;
 
 const sessionArtifactCapabilities = new WeakMap<SessionManager, SessionArtifactCapability>();
@@ -1150,7 +1157,6 @@ export function sessionArtifactCapability(value: unknown): SessionArtifactCapabi
 			capability = Object.freeze({
 				allocateArtifactPath: value.allocateArtifactPath.bind(value),
 				saveArtifact: value.saveArtifact.bind(value),
-				getArtifactPath: value.getArtifactPath.bind(value),
 				putBlob: value.putBlob.bind(value),
 			});
 			sessionArtifactCapabilities.set(value, capability);
@@ -4708,6 +4714,7 @@ export const MATERIALIZED_CACHE_MAX_BYTES = 32 * 1024 * 1024;
 export const SessionManagerTestHooks: {
 	materializedCacheMaxBytesOverride?: number;
 	beforeResidentTransitionIndexBuild?: () => void;
+	afterForkSnapshot?: () => void | Promise<void>;
 } = {};
 
 function materializedCacheMaxBytes(): number {
@@ -4772,6 +4779,10 @@ export class SessionManager {
 	// 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.
 	#adoptedArtifactManager: ArtifactManager | null = null;
+	// In-memory artifact fallback for non-persistent sessions (persist=false).
+	// Keyed by sequential numeric ID string; mirrors the file-based ArtifactManager ID scheme.
+	#inMemoryArtifacts: Map<string, string> | null = null;
+	#inMemoryArtifactCounter = 0;
 	readonly #blobStore: BlobStore;
 	#residentTextBlobStore: BlobStore = new MemoryBlobStore();
 	#residentImageBlobStore: BlobStore;
@@ -5365,6 +5376,8 @@ export class SessionManager {
 		this.#flushed = false;
 		this.#needsFullRewriteOnNextPersist = false;
 		this.#ensuredOnDisk = false;
+		this.#inMemoryArtifacts = null;
+		this.#inMemoryArtifactCounter = 0;
 		this.#artifactManager = null;
 		this.#artifactManagerSessionFile = null;
 		this.#adoptedArtifactManager = null;
@@ -5583,6 +5596,8 @@ export class SessionManager {
 				flushed: this.#flushed,
 				needsFullRewriteOnNextPersist: this.#needsFullRewriteOnNextPersist,
 				ensuredOnDisk: this.#ensuredOnDisk,
+				inMemoryArtifacts: this.#inMemoryArtifacts,
+				inMemoryArtifactCounter: this.#inMemoryArtifactCounter,
 				artifactManager: this.#artifactManager,
 				artifactManagerSessionFile: this.#artifactManagerSessionFile,
 				adoptedArtifactManager: this.#adoptedArtifactManager,
@@ -5605,6 +5620,8 @@ export class SessionManager {
 				this.#flushed = previous.flushed;
 				this.#needsFullRewriteOnNextPersist = previous.needsFullRewriteOnNextPersist;
 				this.#ensuredOnDisk = previous.ensuredOnDisk;
+				this.#inMemoryArtifacts = previous.inMemoryArtifacts;
+				this.#inMemoryArtifactCounter = previous.inMemoryArtifactCounter;
 				this.#artifactManager = previous.artifactManager;
 				this.#artifactManagerSessionFile = previous.artifactManagerSessionFile;
 				this.#adoptedArtifactManager = previous.adoptedArtifactManager;
@@ -6050,6 +6067,8 @@ export class SessionManager {
 		this.#flushed = stage.flushed;
 		this.#needsFullRewriteOnNextPersist = false;
 		this.#ensuredOnDisk = stage.flushed;
+		this.#inMemoryArtifacts = null;
+		this.#inMemoryArtifactCounter = 0;
 		this.#artifactManager = null;
 		this.#artifactManagerSessionFile = null;
 		this.#adoptedArtifactManager = null;
@@ -6154,6 +6173,7 @@ export class SessionManager {
 				const candidate = listing.owned.find(candidate => path.resolve(candidate.path) === requestedPath);
 				if (!candidate) throw new Error("Managed session deletion requires exact logical authorization.");
 				const deleted = await deleteManagedSessionCandidate(resolved.scope, candidate);
+				if (deleted.kind === "error" && deleted.code === "migration_busy") throw new SessionMigrationBusyError();
 				if (deleted.kind !== "deleted" && deleted.kind !== "already_deleted")
 					throw new Error(`Could not delete managed session: ${deleted.message}`);
 			} else {
@@ -6237,6 +6257,8 @@ export class SessionManager {
 			newHeader,
 			...materializedEntries.filter((entry): entry is SessionEntry => entry.type !== "session"),
 		];
+		const forkSnapshotHook = SessionManagerTestHooks.afterForkSnapshot;
+		if (forkSnapshotHook) await forkSnapshotHook();
 
 		await this.#closePersistWriter();
 		this.#persistChain = Promise.resolve();
@@ -7979,19 +8001,17 @@ export class SessionManager {
 	}
 
 	/**
-	 * Save artifact content under the current persisted session and return its artifact ID.
-	 * In-memory sessions cannot produce protocol-resolvable artifact references.
+	 * Save artifact content under the current session and return artifact ID.
+	 * Returns an artifact ID for all sessions (file-backed for persistent, in-memory fallback otherwise).
 	 */
 	async saveArtifact(content: string, toolType: string): Promise<string | undefined> {
 		const manager = this.#getOrCreateArtifactManager();
 		if (manager) return manager.save(content, toolType);
-		return undefined;
-	}
-
-	async saveArtifactReceipt(content: string, toolType: string): Promise<ArtifactSaveReceipt | undefined> {
-		const manager = this.#getOrCreateArtifactManager();
-		if (!manager) return undefined;
-		return manager.saveWithReceipt(content, toolType);
+		// Non-persistent session: store in memory so spill truncation can proceed.
+		if (!this.#inMemoryArtifacts) this.#inMemoryArtifacts = new Map();
+		const id = String(this.#inMemoryArtifactCounter++);
+		this.#inMemoryArtifacts.set(id, content);
+		return id;
 	}
 
 	/**
@@ -9594,6 +9614,7 @@ export class SessionManager {
 				authority,
 			);
 		} catch (error) {
+			if (error instanceof Error && error.message === "migration_busy") throw new SessionMigrationBusyError();
 			if (error instanceof Error && error.message.startsWith("Managed root authority changed"))
 				managedDestinationStore.assertBound();
 			throw error;
@@ -9602,6 +9623,7 @@ export class SessionManager {
 			managedDestinationStore.assertBound();
 			if (opened.code === "legacy_migration_disabled") throw new SessionMigrationPolicyError();
 			if (opened.code === "artifact_capacity_exceeded") throw new SessionArtifactCapacityError(opened.message);
+			if (opened.code === "migration_busy") throw new SessionMigrationBusyError();
 			throw new Error(`Could not open managed session: ${opened.message}`);
 		}
 		assertManagedDestinationBound();
@@ -9697,7 +9719,15 @@ export class SessionManager {
 			throw new Error(`Could not open session: ${inspected.reason}`);
 		}
 		const opened = await SessionManager.openExistingStrict(inspected.identity, destination, storage, migrationPolicy);
-		if (opened.kind === "error") throw new Error(`Could not open session: ${opened.reason}`);
+		if (opened.kind === "error") {
+			if (opened.reason === "legacy_migration_disabled") throw new SessionMigrationPolicyError();
+			if (opened.reason === "artifact_capacity_exceeded")
+				throw new SessionArtifactCapacityError(
+					opened.message ?? "Session artifacts exceed the migration capacity.",
+				);
+			if (opened.reason === "migration_busy") throw new SessionMigrationBusyError();
+			throw new Error(`Could not open session: ${opened.reason}`);
+		}
 		return opened.manager;
 	}
 
@@ -9835,6 +9865,7 @@ export class SessionManager {
 		const candidate = listing.owned.find(item => path.resolve(item.path) === path.resolve(sessionPath));
 		if (!candidate) throw new Error("Session is not an authorized managed candidate.");
 		const deleted = await deleteManagedSessionCandidate(resolved.scope, candidate);
+		if (deleted.kind === "error" && deleted.code === "migration_busy") throw new SessionMigrationBusyError();
 		if (deleted.kind !== "deleted" && deleted.kind !== "already_deleted")
 			throw new Error(`Could not delete managed session: ${deleted.message}`);
 	}
@@ -10380,6 +10411,7 @@ export class SessionManager {
 					return { kind: "error", reason: "legacy_migration_disabled" };
 				if (error instanceof SessionArtifactCapacityError)
 					return { kind: "error", reason: "artifact_capacity_exceeded", message: error.message };
+				if (error instanceof SessionMigrationBusyError) return { kind: "error", reason: "migration_busy" };
 				if (
 					error instanceof Error &&
 					(error.message.includes("source_changed") || error.message.includes("changed before migration"))
@@ -10442,6 +10474,7 @@ export class SessionManager {
 					throw new SessionArtifactCapacityError(
 						opened.message ?? "Session artifacts exceed the migration capacity.",
 					);
+				if (opened.reason === "migration_busy") throw new SessionMigrationBusyError();
 				return undefined;
 			}
 			return opened.manager;

package/src/session/session-storage.ts

@@ -312,6 +312,7 @@ export type VerifiedSessionDeleteResult =
 			artifactsIdentity: SessionStorageFileIdentity | undefined;
 			/** Identity-bound quarantine path retained when recursive cleanup failed. */
 			detachedArtifactsPath: string;
+			artifactsPayloadDurable?: true;
 			/** Native snapshot required for an identity-bound recursive retry. */
 			artifactsTree: NativeDirectoryTreeSnapshot;
 			/** Transcript identity (unchanged) for retry binding. */
@@ -328,6 +329,7 @@ export type VerifiedSessionDeleteResult =
 			transcriptIdentity: SessionStorageFileIdentity;
 			/** Optional identity-bound transcript quarantine path for restart cleanup. */
 			detachedTranscriptPath?: string;
+			transcriptPayloadDurable?: true;
 			retainedSuccessorPath?: string;
 			retainedPlaceholderPath?: string;
 			retainedUnknownPath?: string;
@@ -423,6 +425,7 @@ type NativeDirectoryTreeApi = {
 function nativeDirectoryTreeApi(): NativeDirectoryTreeApi {
 	return native as unknown as NativeDirectoryTreeApi;
 }
+
 function snapshotDirectoryTree(pathname: string): NativeDirectoryTreeSnapshot {
 	const result = nativeDirectoryTreeApi().snapshotDirectoryTree(pathname);
 	if (!result.ok || !result.snapshot)
@@ -438,10 +441,21 @@ function retainedTreeDoesNotExpandAuthority(
 ): boolean {
 	if (expected.rootDev !== retained.rootDev || expected.rootIno !== retained.rootIno) return false;
 	const expectedEntries = new Map(expected.entries.map(entry => [entry.relativePath, entry]));
+	if (retained.entries.length > expected.entries.length) return false;
 	return retained.entries.every(entry => {
 		if (entry.relativePath === "") return entry.kind === "directory";
 		const authorized = expectedEntries.get(entry.relativePath);
-		return authorized !== undefined && JSON.stringify(authorized) === JSON.stringify(entry);
+		if (
+			authorized === undefined ||
+			authorized.kind !== entry.kind ||
+			authorized.dev !== entry.dev ||
+			authorized.ino !== entry.ino ||
+			authorized.nlink !== entry.nlink
+		)
+			return false;
+		if (entry.kind !== "file") return entry.size === authorized.size;
+		const scrubbed = entry.size === "0" && entry.sha256 === createHash("sha256").update("").digest("hex");
+		return scrubbed || (entry.size === authorized.size && entry.sha256 === authorized.sha256);
 	});
 }
 
@@ -938,7 +952,7 @@ export class FileSessionStorage implements SessionStorage {
 				"Transcript parent identity does not match authorization",
 			);
 		const authorizedTranscriptParentIdentity = transcriptParentIdentity ?? parentIdentity;
-		if (detachedArtifactsPath) {
+		if (detachedArtifactsPath && !artifactsRemoved) {
 			if (
 				!expectedArtifactsIdentity ||
 				path.dirname(detachedArtifactsPath) !== path.dirname(transcriptPath) ||
@@ -997,6 +1011,9 @@ export class FileSessionStorage implements SessionStorage {
 					artifactsIdentity: expectedArtifactsIdentity,
 					detachedArtifactsPath: retainedRoot,
 					artifactsTree: retainedTree,
+					...((removal as typeof removal & { payloadDurable?: boolean }).payloadDurable === true
+						? { artifactsPayloadDurable: true as const }
+						: {}),
 					...((removal.retainedSuccessorPath ?? retainedArtifactsSuccessorPath)
 						? { retainedSuccessorPath: removal.retainedSuccessorPath ?? retainedArtifactsSuccessorPath }
 						: {}),
@@ -1045,6 +1062,24 @@ export class FileSessionStorage implements SessionStorage {
 				"Artifact path reappeared after durable artifact-phase completion",
 			);
 		}
+		if (artifactsRemoved && detachedArtifactsPath && expectedArtifactsIdentity && expectedArtifactsTree) {
+			const retainedIdentity = this.#optionalDirectoryIdentity(detachedArtifactsPath);
+			if (
+				!retainedIdentity ||
+				retainedIdentity.dev !== expectedArtifactsIdentity.dev ||
+				retainedIdentity.ino !== expectedArtifactsIdentity.ino
+			)
+				throw new SessionDeleteVerificationError(
+					"artifacts",
+					"Retained artifact root identity changed before transcript cleanup",
+				);
+			const retainedTree = snapshotDirectoryTree(detachedArtifactsPath);
+			if (!retainedTreeDoesNotExpandAuthority(expectedArtifactsTree, retainedTree))
+				throw new SessionDeleteVerificationError(
+					"artifacts",
+					"Partial artifact cleanup expanded retained tree authority",
+				);
+		}
 		if (!artifactsIdentity && expectedArtifactsIdentity && !detachedArtifactsPath && !artifactsRemoved) {
 			// Absence at the original path alone is not completion: native recursive removal
 			// may retain the planned root or its deterministic `.removing` final-stage root.
@@ -1116,12 +1151,22 @@ export class FileSessionStorage implements SessionStorage {
 						throw new Error("parent_changed");
 					fs.fsyncSync(descriptor);
 				} catch (error) {
-					throw new SessionDeleteVerificationError("artifacts", "durability_failed", { cause: toError(error) });
+					return {
+						kind: "cleanup_pending",
+						phase: "artifacts",
+						error: new SessionDeleteVerificationError("artifacts", "durability_failed", {
+							cause: toError(error),
+						}),
+						artifactsIdentity,
+						detachedArtifactsPath: detach.detachedPath,
+						artifactsTree,
+						transcriptIdentity,
+					};
 				} finally {
 					if (descriptor !== undefined) fs.closeSync(descriptor);
 				}
 			}
-			if (!detach.ok) {
+			if (!detach.ok && process.platform === "win32") {
 				return {
 					kind: "cleanup_pending",
 					phase: "artifacts",
@@ -1132,7 +1177,6 @@ export class FileSessionStorage implements SessionStorage {
 					...(detach.retainedSuccessorPath ? { retainedSuccessorPath: detach.retainedSuccessorPath } : {}),
 					...(detach.retainedPlaceholderPath ? { retainedPlaceholderPath: detach.retainedPlaceholderPath } : {}),
 					...(detach.retainedUnknownPath ? { retainedUnknownPath: detach.retainedUnknownPath } : {}),
-
 					transcriptIdentity,
 				};
 			}
@@ -1173,6 +1217,9 @@ export class FileSessionStorage implements SessionStorage {
 					artifactsIdentity,
 					detachedArtifactsPath: retainedRoot,
 					artifactsTree: retainedTree,
+					...((removal as typeof removal & { payloadDurable?: boolean }).payloadDurable === true
+						? { artifactsPayloadDurable: true as const }
+						: {}),
 					...((removal.retainedSuccessorPath ?? retainedArtifactsSuccessorPath)
 						? { retainedSuccessorPath: removal.retainedSuccessorPath ?? retainedArtifactsSuccessorPath }
 						: {}),
@@ -1223,6 +1270,13 @@ export class FileSessionStorage implements SessionStorage {
 				quarantineName: path.basename(plannedTranscriptPath),
 			});
 			if (!deletion.ok) {
+				if (
+					deletion.code === "cleanup_pending" &&
+					(deletion as typeof deletion & { payloadDurable?: boolean }).payloadDurable === true &&
+					deletion.retainedSuccessorPath === undefined &&
+					deletion.retainedUnknownPath === undefined
+				)
+					return { kind: "deleted" };
 				const error = exactUnlinkFailure(deletion);
 				const retainedAuthority =
 					deletion.detachedPath ||
@@ -1234,6 +1288,9 @@ export class FileSessionStorage implements SessionStorage {
 					kind: "cleanup_pending",
 					phase: "transcript",
 					error,
+					...((deletion as typeof deletion & { payloadDurable?: boolean }).payloadDurable === true
+						? { transcriptPayloadDurable: true as const }
+						: {}),
 					transcriptIdentity,
 					detachedTranscriptPath: deletion.detachedPath ?? detachedTranscriptPath,
 					...((deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath)
@@ -1288,6 +1345,13 @@ export class FileSessionStorage implements SessionStorage {
 			quarantineName: path.basename(plannedTranscriptPath),
 		});
 		if (!deletion.ok) {
+			if (
+				deletion.code === "cleanup_pending" &&
+				(deletion as typeof deletion & { payloadDurable?: boolean }).payloadDurable === true &&
+				deletion.retainedSuccessorPath === undefined &&
+				deletion.retainedUnknownPath === undefined
+			)
+				return { kind: "deleted" };
 			const error = exactUnlinkFailure(deletion);
 			const retainedAuthority =
 				deletion.detachedPath ||
@@ -1299,6 +1363,9 @@ export class FileSessionStorage implements SessionStorage {
 				kind: "cleanup_pending",
 				phase: "transcript",
 				error,
+				...((deletion as typeof deletion & { payloadDurable?: boolean }).payloadDurable === true
+					? { transcriptPayloadDurable: true as const }
+					: {}),
 				transcriptIdentity,
 				detachedTranscriptPath: deletion.detachedPath,
 				...((deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath)