@gajae-code/coding-agent 0.18.7 → 0.18.9

package/src/session/session-storage.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import * as util from "node:util";
 
 import type * as native from "@gajae-code/natives";
 
@@ -15,6 +16,7 @@ function nativeSessionStorage(): typeof import("@gajae-code/natives") {
 }
 
 import { isEnoent, pathIsWithin, peekFile, toError } from "@gajae-code/utils";
+import type { ManagedGcProtocolScopeInspector } from "./internal/managed-session-scope";
 import {
 	assertManagedDirectoryRoot,
 	type ManagedDirectoryRoot,
@@ -28,7 +30,26 @@ import {
 	type NativePublishOutcome,
 } from "./internal/native-publish-outcome";
 import { isDerivedSessionMemoryFile } from "./internal/session-memory-sidecar";
+import { captureTaskArtifactOwnerDeletionEvidence } from "./internal/task-artifact-owner-access";
+import {
+	hasSiblingTaskArtifactOwnerTranscript,
+	taskArtifactOwnerLocatorFromTranscriptBytes,
+} from "./internal/task-artifact-owner-transcript";
 import { parseFirstJsonlLine } from "./session-transcript-header";
+import {
+	parseTaskArtifactOwnerDeletionEvidence,
+	parseTaskArtifactOwnerRetirementOutcome,
+	type TaskArtifactOwnerDeletionEvidence,
+	type TaskArtifactOwnerLocator,
+	type TaskArtifactOwnerRetirementContinuation,
+	type TaskArtifactOwnerRetirementOutcome,
+	type TaskArtifactOwnerStorageContext,
+} from "./task-artifact-owner-codec";
+import {
+	retireTaskArtifactOwner,
+	verifyTaskArtifactOwnerPhysicalRetirement,
+	verifyTaskArtifactOwnerRetirementContinuation,
+} from "./task-artifact-owner-retirement";
 
 const utf8Decoder = new TextDecoder("utf-8");
 const newlineBuffer = Buffer.from("\n", "utf8");
@@ -443,8 +464,24 @@ export interface VerifiedSessionDeleteTarget {
 	retainedTranscriptSuccessorPath?: string;
 	/** Native-retained exchange placeholder observed during transcript cleanup. */
 	retainedTranscriptPlaceholderPath?: string;
-	/** Native-retained transcript entry whose identity could not be verified. */
+	/** Native-retained entry whose identity could not be verified. */
 	retainedTranscriptUnknownPath?: string;
+	/** Trusted managed authority for the path-free persisted task-artifact locator. */
+	taskArtifactOwnerStorageContext?: TaskArtifactOwnerStorageContext;
+	/** Exact owner-tree evidence captured before deletion and retained across retries. */
+	taskArtifactOwnerDeletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+	/** Owning journal persists the full native disposition across delete effects. */
+	taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+	/** Native terminal evidence of logical transcript deletion; pathname absence alone is insufficient. */
+	taskArtifactOwnerTranscriptDeleted?: true;
+	/** Explicitly leave owner retirement to its owning coordinator. */
+	deferTaskArtifactOwnerRetirement?: true;
+	/** Durable evidence that exact owner retirement completed. */
+	taskArtifactOwnerRetired?: true;
+	/** Exact native remnant, separate from immutable original authority. */
+	taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+	taskArtifactOwnerPayloadRetired?: true;
+	taskArtifactOwnerNamespaceRetained?: true;
 	/** Native-retained publisher successor observed during cleanup. */
 	retainedArtifactsSuccessorPath?: string;
 	/** Native-retained exchange placeholder observed during cleanup. */
@@ -467,8 +504,28 @@ export interface VerifiedSessionDeleteTarget {
  * `deleted` and never `{}`.
  */
 export type VerifiedSessionDeleteResult =
-	| { kind: "artifacts_removed"; phase: "artifacts"; transcriptIdentity: SessionStorageFileIdentity }
-	| { kind: "deleted" }
+	| {
+			kind: "artifacts_removed";
+			phase: "artifacts";
+			transcriptIdentity: SessionStorageFileIdentity;
+			taskArtifactOwnerDeletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+			taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+			taskArtifactOwnerTranscriptDeleted?: true;
+			taskArtifactOwnerRetired?: true;
+			taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+			taskArtifactOwnerPayloadRetired?: true;
+			taskArtifactOwnerNamespaceRetained?: true;
+	  }
+	| {
+			kind: "deleted";
+			taskArtifactOwnerDeletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+			taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+			taskArtifactOwnerTranscriptDeleted?: true;
+			taskArtifactOwnerRetired?: true;
+			taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+			taskArtifactOwnerPayloadRetired?: true;
+			taskArtifactOwnerNamespaceRetained?: true;
+	  }
 	| {
 			kind: "cleanup_pending";
 			phase: "artifacts";
@@ -485,6 +542,28 @@ export type VerifiedSessionDeleteResult =
 			retainedSuccessorPath?: string;
 			retainedPlaceholderPath?: string;
 			retainedUnknownPath?: string;
+			taskArtifactOwnerDeletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+			taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+			taskArtifactOwnerTranscriptDeleted?: true;
+			taskArtifactOwnerRetired?: true;
+			taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+			taskArtifactOwnerPayloadRetired?: true;
+			taskArtifactOwnerNamespaceRetained?: true;
+	  }
+	| {
+			kind: "cleanup_pending";
+			phase: "task_artifact_owner";
+			/** True only after verified artifact completion, never inferred from the failure phase. */
+			artifactsRemoved: boolean;
+			error: Error;
+			transcriptIdentity: SessionStorageFileIdentity;
+			taskArtifactOwnerDeletionEvidence: TaskArtifactOwnerDeletionEvidence;
+			taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+			taskArtifactOwnerTranscriptDeleted?: true;
+			taskArtifactOwnerRetired?: true;
+			taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+			taskArtifactOwnerPayloadRetired?: true;
+			taskArtifactOwnerNamespaceRetained?: true;
 	  }
 	| {
 			kind: "cleanup_pending";
@@ -498,6 +577,13 @@ export type VerifiedSessionDeleteResult =
 			retainedSuccessorPath?: string;
 			retainedPlaceholderPath?: string;
 			retainedUnknownPath?: string;
+			taskArtifactOwnerDeletionEvidence?: TaskArtifactOwnerDeletionEvidence;
+			taskArtifactOwnerRetirementOutcome?: TaskArtifactOwnerRetirementOutcome;
+			taskArtifactOwnerTranscriptDeleted?: true;
+			taskArtifactOwnerRetired?: true;
+			taskArtifactOwnerRetirementContinuation?: TaskArtifactOwnerRetirementContinuation;
+			taskArtifactOwnerPayloadRetired?: true;
+			taskArtifactOwnerNamespaceRetained?: true;
 	  };
 
 /** Default OS-close dispatcher: a direct `fs.closeSync`. */
@@ -736,6 +822,34 @@ function secureOwnerOnlyFileDescriptor(
 	if (!result.ok) throw new Error(`Owner-only security rejected ${pathname}: ${result.code}`);
 }
 
+/**
+ * Replace an explicit session file. Creation mode `0600` does not install a
+ * Windows owner-only DACL, so this applies and verifies the same native path a
+ * primary transcript uses when it has no managed security context. POSIX mode
+ * stays `0600`.
+ */
+export function writeExplicitOwnerOnlyTextSync(pathname: string, content: string): void {
+	const fd = fs.openSync(
+		pathname,
+		fs.constants.O_WRONLY | fs.constants.O_CREAT | (fs.constants.O_NOFOLLOW ?? 0),
+		0o600,
+	);
+	try {
+		secureOwnerOnlyFileDescriptor(pathname, fd, "apply", undefined);
+		fs.ftruncateSync(fd, 0);
+		const bytes = Buffer.from(content, "utf8");
+		let offset = 0;
+		while (offset < bytes.byteLength) {
+			const written = fs.writeSync(fd, bytes, offset, bytes.byteLength - offset);
+			if (written === 0) throw new Error("Short write");
+			offset += written;
+		}
+		secureOwnerOnlyFileDescriptor(pathname, fd, "verify", undefined);
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
 /** Reject a symlink/junction/reparse component before a storage path is created or opened. */
 function assertNoReparsePath(pathname: string): void {
 	const resolved = path.resolve(pathname);
@@ -1987,7 +2101,8 @@ export class FileSessionStorage implements SessionStorage {
 
 	writeTextSync(fpath: string, content: string): void {
 		this.ensureDirSync(path.dirname(fpath));
-		fs.writeFileSync(fpath, content);
+		// New fork and branch transcripts are created here.
+		writeExplicitOwnerOnlyTextSync(fpath, content);
 	}
 
 	readTextSync(fpath: string): string {
@@ -2265,7 +2380,10 @@ export class FileSessionStorage implements SessionStorage {
 	 * revalidate, transcript last. Partial deletion returns typed cleanup_pending
 	 * evidence; identity/symlink/containment/header/cwd mismatch throws.
 	 */
-	async deleteSessionVerified(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult> {
+	async deleteSessionVerified(
+		target: VerifiedSessionDeleteTarget,
+		inspectProtocol?: ManagedGcProtocolScopeInspector,
+	): Promise<VerifiedSessionDeleteResult> {
 		const {
 			sessionsRoot,
 			transcriptPath,
@@ -2287,6 +2405,15 @@ export class FileSessionStorage implements SessionStorage {
 			plannedArtifactsPath,
 			plannedTranscriptPath,
 			artifactsRemoved,
+			taskArtifactOwnerStorageContext,
+			taskArtifactOwnerDeletionEvidence: ownerEvidenceValue,
+			deferTaskArtifactOwnerRetirement,
+			taskArtifactOwnerRetirementOutcome: ownerOutcomeValue,
+			taskArtifactOwnerTranscriptDeleted: ownerTranscriptDeletedValue,
+			taskArtifactOwnerRetired: ownerRetiredValue,
+			taskArtifactOwnerRetirementContinuation: ownerContinuationValue,
+			taskArtifactOwnerPayloadRetired: ownerPayloadRetiredValue,
+			taskArtifactOwnerNamespaceRetained: ownerNamespaceRetainedValue,
 		} = target;
 		try {
 			assertNoReparsePath(sessionsRoot);
@@ -2302,6 +2429,16 @@ export class FileSessionStorage implements SessionStorage {
 		if (!pathIsWithin(sessionsRoot, transcriptPath)) {
 			throw new SessionDeleteVerificationError("containment", "Transcript is outside the sessions root");
 		}
+		if (
+			taskArtifactOwnerStorageContext &&
+			path.resolve(taskArtifactOwnerStorageContext.sessionsRoot) !== path.resolve(sessionsRoot)
+		)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_root_mismatch");
+		if (
+			(ownerTranscriptDeletedValue !== undefined && ownerTranscriptDeletedValue !== true) ||
+			(deferTaskArtifactOwnerRetirement !== undefined && deferTaskArtifactOwnerRetirement !== true)
+		)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_flag_invalid");
 		if (
 			!plannedArtifactsPath ||
 			!plannedTranscriptPath ||
@@ -2355,6 +2492,243 @@ export class FileSessionStorage implements SessionStorage {
 				"Transcript parent identity does not match authorization",
 			);
 		const authorizedTranscriptParentIdentity = transcriptParentIdentity ?? parentIdentity;
+		let initial: { snapshot: SessionStorageSnapshot } | undefined;
+		if (ownerTranscriptDeletedValue === true && fs.existsSync(transcriptPath))
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_transcript_deleted_mismatch");
+		if (!hasDetachedTranscript && ownerTranscriptDeletedValue !== true) {
+			try {
+				initial = this.#verifiedReadAndHeader(transcriptPath, sessionId, cwd);
+			} catch (error) {
+				const absent =
+					error instanceof SessionDeleteVerificationError &&
+					error.kind === "stat" &&
+					(error.cause as NodeJS.ErrnoException | undefined)?.code === "ENOENT";
+				if (!absent || !detachedArtifactsPath || artifactsRemoved) throw error;
+			}
+		}
+		const ownerTranscript =
+			ownerTranscriptDeletedValue === true
+				? undefined
+				: (initial ??
+					(hasDetachedTranscript && fs.existsSync(cleanupTranscriptPath)
+						? this.#verifiedReadAndHeader(cleanupTranscriptPath, sessionId, cwd)
+						: undefined));
+		let ownerLocator: TaskArtifactOwnerLocator | undefined;
+		try {
+			ownerLocator = ownerTranscript
+				? taskArtifactOwnerLocatorFromTranscriptBytes(ownerTranscript.snapshot.bytes, sessionId)
+				: undefined;
+		} catch (error) {
+			const failure = toError(error);
+			if (failure.message.startsWith("task_artifact_owner_")) throw failure;
+			throw new SessionDeleteVerificationError("artifacts", `task_artifact_owner_patch_invalid:${failure.message}`, {
+				cause: failure,
+			});
+		}
+		const withTaskArtifactOwnerFailure = <T>(operation: () => T): T => {
+			try {
+				return operation();
+			} catch (error) {
+				const failure = toError(error);
+				if (failure.message.startsWith("task_artifact_owner_")) throw failure;
+				throw new SessionDeleteVerificationError(
+					"artifacts",
+					`task_artifact_owner_cleanup_failed:${failure.message}`,
+					{ cause: failure },
+				);
+			}
+		};
+		let ownerEvidence = ownerEvidenceValue
+			? withTaskArtifactOwnerFailure(() => parseTaskArtifactOwnerDeletionEvidence(ownerEvidenceValue))
+			: undefined;
+		if (ownerEvidence && ownerEvidence.sessionId !== sessionId)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_session_mismatch");
+		if (ownerLocator && ownerEvidence && !util.isDeepStrictEqual(ownerLocator, ownerEvidence.locator))
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_locator_mismatch");
+		if (ownerLocator && !ownerEvidence && taskArtifactOwnerStorageContext)
+			ownerEvidence = withTaskArtifactOwnerFailure(() =>
+				captureTaskArtifactOwnerDeletionEvidence(taskArtifactOwnerStorageContext, sessionId, ownerLocator),
+			);
+		if (ownerLocator && !ownerEvidence)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_locator_missing");
+		if (ownerEvidence && ownerTranscript && !ownerLocator)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_evidence_not_in_transcript");
+		if (ownerEvidence && !taskArtifactOwnerStorageContext)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_context_missing");
+		if (ownerLocator && deferTaskArtifactOwnerRetirement && (!ownerEvidence || !taskArtifactOwnerStorageContext))
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_defer_evidence_missing");
+		if (ownerTranscriptDeletedValue === true && !ownerEvidence)
+			throw new SessionDeleteVerificationError(
+				"artifacts",
+				"task_artifact_owner_transcript_deleted_evidence_missing",
+			);
+		let ownerOutcome =
+			ownerOutcomeValue !== undefined && ownerEvidence && taskArtifactOwnerStorageContext
+				? withTaskArtifactOwnerFailure(() =>
+						parseTaskArtifactOwnerRetirementOutcome(
+							taskArtifactOwnerStorageContext,
+							ownerEvidence!,
+							ownerOutcomeValue,
+						),
+					)
+				: undefined;
+		if (ownerOutcomeValue !== undefined && !ownerOutcome)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_retirement_outcome_missing");
+		if (
+			ownerTranscriptDeletedValue === true &&
+			ownerOutcome?.kind !== "completed" &&
+			ownerOutcome?.kind !== "payload_retired"
+		)
+			throw new SessionDeleteVerificationError(
+				"artifacts",
+				"task_artifact_owner_transcript_deleted_outcome_missing",
+			);
+		if ((ownerContinuationValue !== undefined) !== (ownerOutcome !== undefined && ownerOutcome.kind !== "completed"))
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_retirement_continuation_mismatch");
+		if (
+			ownerOutcome &&
+			ownerOutcome.kind !== "completed" &&
+			!util.isDeepStrictEqual(ownerContinuationValue, ownerOutcome.continuation)
+		)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_retirement_continuation_mismatch");
+		const ownerContinuationRecord =
+			ownerOutcome && ownerOutcome.kind !== "completed" ? ownerOutcome.continuation : undefined;
+		let ownerContinuation = ownerContinuationRecord
+			? withTaskArtifactOwnerFailure(() =>
+					verifyTaskArtifactOwnerRetirementContinuation(
+						taskArtifactOwnerStorageContext!,
+						ownerEvidence!,
+						ownerContinuationRecord,
+					),
+				)
+			: undefined;
+		const payloadRetired = ownerOutcome?.kind === "payload_retired";
+		if (
+			(ownerRetiredValue !== undefined && ownerRetiredValue !== true) ||
+			(ownerPayloadRetiredValue !== undefined && ownerPayloadRetiredValue !== true) ||
+			(ownerNamespaceRetainedValue !== undefined && ownerNamespaceRetainedValue !== true) ||
+			(ownerRetiredValue === true) !== (ownerOutcome?.kind === "completed") ||
+			(ownerPayloadRetiredValue === true) !== payloadRetired ||
+			(ownerNamespaceRetainedValue === true) !== payloadRetired
+		)
+			throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_retirement_outcome_mismatch");
+		if (ownerRetiredValue === true) {
+			if (!ownerEvidence || !taskArtifactOwnerStorageContext || !ownerOutcome)
+				throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_retired_evidence_missing");
+			withTaskArtifactOwnerFailure(() =>
+				verifyTaskArtifactOwnerPhysicalRetirement(taskArtifactOwnerStorageContext, ownerEvidence!, ownerOutcome),
+			);
+		}
+		if (
+			ownerEvidence &&
+			ownerLocator &&
+			taskArtifactOwnerStorageContext &&
+			!ownerContinuation &&
+			!ownerRetiredValue
+		) {
+			const current = withTaskArtifactOwnerFailure(() =>
+				captureTaskArtifactOwnerDeletionEvidence(taskArtifactOwnerStorageContext, sessionId, ownerLocator),
+			);
+			if (!current || !util.isDeepStrictEqual(current, ownerEvidence))
+				throw new SessionDeleteVerificationError("artifacts", "task_artifact_owner_changed_since_capture");
+		}
+		let ownerRetired = ownerRetiredValue === true;
+		let ownerPayloadRetired = ownerPayloadRetiredValue === true;
+		let ownerNamespaceRetained = ownerNamespaceRetainedValue === true;
+		let ownerTranscriptDeleted = ownerTranscriptDeletedValue === true;
+		const ownerSiblingRefusal = async (): Promise<Error | undefined> => {
+			// Deferral changes who retires the owner, not the pre-artifact sibling authority boundary.
+			if (!ownerEvidence) return undefined;
+			if (!taskArtifactOwnerStorageContext)
+				return new SessionDeleteVerificationError("artifacts", "task_artifact_owner_context_missing");
+			try {
+				if (
+					await hasSiblingTaskArtifactOwnerTranscript(
+						this,
+						transcriptPath,
+						ownerEvidence.locator,
+						taskArtifactOwnerStorageContext,
+						inspectProtocol,
+					)
+				)
+					return new SessionDeleteVerificationError(
+						"artifacts",
+						"task_artifact_owner_shared_with_sibling_transcript",
+					);
+				return undefined;
+			} catch (error) {
+				return new SessionDeleteVerificationError(
+					"artifacts",
+					`task_artifact_owner_cleanup_failed:${toError(error).message}`,
+					{ cause: toError(error) },
+				);
+			}
+		};
+		const retireOwnerIfRequired = async (): Promise<Error | undefined> => {
+			const refusal = await ownerSiblingRefusal();
+			if (refusal) return refusal;
+			if (deferTaskArtifactOwnerRetirement || ownerRetired || !ownerEvidence || !taskArtifactOwnerStorageContext)
+				return undefined;
+			try {
+				ownerOutcome = withTaskArtifactOwnerFailure(() =>
+					retireTaskArtifactOwner(taskArtifactOwnerStorageContext, ownerEvidence!, ownerContinuation),
+				);
+				if (ownerOutcome.kind === "completed") {
+					ownerRetired = true;
+					ownerContinuation = undefined;
+					ownerPayloadRetired = false;
+					ownerNamespaceRetained = false;
+					return undefined;
+				}
+				ownerContinuation = ownerOutcome.continuation;
+				ownerPayloadRetired = ownerOutcome.kind === "payload_retired";
+				ownerNamespaceRetained = ownerOutcome.kind === "payload_retired";
+				return new SessionDeleteVerificationError(
+					"artifacts",
+					ownerOutcome.kind === "uncertain"
+						? ownerOutcome.reason
+						: "task_artifact_owner_namespace_cleanup_pending",
+				);
+			} catch (error) {
+				return new SessionDeleteVerificationError(
+					"artifacts",
+					`task_artifact_owner_cleanup_failed:${toError(error).message}`,
+					{ cause: toError(error) },
+				);
+			}
+		};
+		const ownerResultFields = () => ({
+			...(ownerEvidence ? { taskArtifactOwnerDeletionEvidence: ownerEvidence } : {}),
+			...(ownerOutcome ? { taskArtifactOwnerRetirementOutcome: ownerOutcome } : {}),
+			...(ownerTranscriptDeleted ? { taskArtifactOwnerTranscriptDeleted: true as const } : {}),
+			...(ownerRetired ? { taskArtifactOwnerRetired: true as const } : {}),
+			...(ownerContinuation ? { taskArtifactOwnerRetirementContinuation: ownerContinuation } : {}),
+			...(ownerPayloadRetired ? { taskArtifactOwnerPayloadRetired: true as const } : {}),
+			...(ownerNamespaceRetained ? { taskArtifactOwnerNamespaceRetained: true as const } : {}),
+		});
+		const ownerCleanupPending = (error: Error, completedArtifacts: boolean): VerifiedSessionDeleteResult => ({
+			kind: "cleanup_pending",
+			phase: "task_artifact_owner",
+			artifactsRemoved: completedArtifacts,
+			error,
+			transcriptIdentity,
+			taskArtifactOwnerDeletionEvidence: ownerEvidence!,
+			...ownerResultFields(),
+		});
+		const finishArtifactPhase = async (): Promise<VerifiedSessionDeleteResult> => {
+			const ownerError = await retireOwnerIfRequired();
+			if (ownerError && ownerEvidence) return ownerCleanupPending(ownerError, true);
+			if (ownerTranscriptDeleted) return { kind: "deleted", ...ownerResultFields() };
+			return {
+				kind: "artifacts_removed",
+				phase: "artifacts",
+				transcriptIdentity,
+				...ownerResultFields(),
+			};
+		};
+		const ownerPreflightError = await ownerSiblingRefusal();
+		if (ownerPreflightError && ownerEvidence)
+			return ownerCleanupPending(ownerPreflightError, artifactsRemoved === true);
 		if (detachedArtifactsPath && !artifactsRemoved) {
 			if (
 				!expectedArtifactsIdentity ||
@@ -2427,16 +2801,16 @@ export class FileSessionStorage implements SessionStorage {
 						? { retainedUnknownPath: removal.retainedUnknownPath ?? retainedArtifactsUnknownPath }
 						: {}),
 					transcriptIdentity,
+					...ownerResultFields(),
 				};
 			}
-			return { kind: "artifacts_removed", phase: "artifacts", transcriptIdentity };
+			return await finishArtifactPhase();
 		}
 		if (transcriptIdentity.nlink === undefined || transcriptIdentity.nlink !== 1n)
 			throw new SessionDeleteVerificationError(
 				"identity",
 				"Single-link transcript authority is required for exact deletion",
 			);
-		const initial = hasDetachedTranscript ? undefined : this.#verifiedReadAndHeader(transcriptPath, sessionId, cwd);
 		const initialStat = initial?.snapshot.stat;
 		const initialDigest = initial ? createHash("sha256").update(initial.snapshot.bytes).digest("hex") : undefined;
 		if (
@@ -2491,7 +2865,7 @@ export class FileSessionStorage implements SessionStorage {
 					"artifacts",
 					"Authorized artifact removal root remains after restart",
 				);
-			return { kind: "artifacts_removed", phase: "artifacts", transcriptIdentity };
+			return await finishArtifactPhase();
 		}
 
 		if (artifactsIdentity && !artifactsRemoved) {
@@ -2564,6 +2938,7 @@ export class FileSessionStorage implements SessionStorage {
 						detachedArtifactsPath: detach.detachedPath,
 						artifactsTree,
 						transcriptIdentity,
+						...ownerResultFields(),
 					};
 				} finally {
 					if (descriptor !== undefined) fs.closeSync(descriptor);
@@ -2581,6 +2956,7 @@ export class FileSessionStorage implements SessionStorage {
 					...(detach.retainedPlaceholderPath ? { retainedPlaceholderPath: detach.retainedPlaceholderPath } : {}),
 					...(detach.retainedUnknownPath ? { retainedUnknownPath: detach.retainedUnknownPath } : {}),
 					transcriptIdentity,
+					...ownerResultFields(),
 				};
 			}
 			const removal = removeDirectoryTreeExact(
@@ -2633,6 +3009,7 @@ export class FileSessionStorage implements SessionStorage {
 						? { retainedUnknownPath: removal.retainedUnknownPath ?? retainedArtifactsUnknownPath }
 						: {}),
 					transcriptIdentity,
+					...ownerResultFields(),
 				};
 			}
 		}
@@ -2658,8 +3035,19 @@ export class FileSessionStorage implements SessionStorage {
 					if (descriptor !== undefined) fs.closeSync(descriptor);
 				}
 			}
-			return { kind: "artifacts_removed", phase: "artifacts", transcriptIdentity };
+			return await finishArtifactPhase();
 		}
+		if (deferTaskArtifactOwnerRetirement && ownerEvidence && !ownerRetired && !ownerPayloadRetired) {
+			return {
+				kind: "artifacts_removed",
+				phase: "artifacts",
+				transcriptIdentity,
+				...ownerResultFields(),
+			};
+		}
+		const ownerError = await retireOwnerIfRequired();
+		if (ownerError && ownerEvidence) return ownerCleanupPending(ownerError, true);
+		if (ownerTranscriptDeleted) return { kind: "deleted", ...ownerResultFields() };
 		if (hasDetachedTranscript) {
 			const deletion = nativeExactUnlink(cleanupTranscriptPath, {
 				dev: transcriptIdentity.dev,
@@ -2673,7 +3061,10 @@ export class FileSessionStorage implements SessionStorage {
 				quarantineName: path.basename(plannedTranscriptPath),
 			});
 			if (!deletion.ok) {
-				if (transcriptDeletionTerminal(deletion)) return { kind: "deleted" };
+				if (transcriptDeletionTerminal(deletion)) {
+					if (ownerEvidence) ownerTranscriptDeleted = true;
+					return { kind: "deleted", ...ownerResultFields() };
+				}
 				const error = exactUnlinkFailure(deletion);
 				const retainedAuthority =
 					deletion.detachedPath ||
@@ -2689,6 +3080,7 @@ export class FileSessionStorage implements SessionStorage {
 						? { transcriptPayloadDurable: true as const }
 						: {}),
 					transcriptIdentity,
+					...ownerResultFields(),
 					detachedTranscriptPath: deletion.detachedPath ?? detachedTranscriptPath,
 					...((deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath)
 						? { retainedSuccessorPath: deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath }
@@ -2701,7 +3093,8 @@ export class FileSessionStorage implements SessionStorage {
 						: {}),
 				};
 			}
-			return { kind: "deleted" };
+			if (ownerEvidence) ownerTranscriptDeleted = true;
+			return { kind: "deleted", ...ownerResultFields() };
 		}
 		if (!initialStat || !initialDigest)
 			throw new SessionDeleteVerificationError("stat", "Transcript cleanup state is invalid");
@@ -2742,7 +3135,10 @@ export class FileSessionStorage implements SessionStorage {
 			quarantineName: path.basename(plannedTranscriptPath),
 		});
 		if (!deletion.ok) {
-			if (transcriptDeletionTerminal(deletion)) return { kind: "deleted" };
+			if (transcriptDeletionTerminal(deletion)) {
+				if (ownerEvidence) ownerTranscriptDeleted = true;
+				return { kind: "deleted", ...ownerResultFields() };
+			}
 			const error = exactUnlinkFailure(deletion);
 			const retainedAuthority =
 				deletion.detachedPath ||
@@ -2758,6 +3154,7 @@ export class FileSessionStorage implements SessionStorage {
 					? { transcriptPayloadDurable: true as const }
 					: {}),
 				transcriptIdentity,
+				...ownerResultFields(),
 				detachedTranscriptPath: deletion.detachedPath,
 				...((deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath)
 					? { retainedSuccessorPath: deletion.retainedSuccessorPath ?? retainedTranscriptSuccessorPath }
@@ -2770,7 +3167,8 @@ export class FileSessionStorage implements SessionStorage {
 					: {}),
 			};
 		}
-		return { kind: "deleted" };
+		if (ownerEvidence) ownerTranscriptDeleted = true;
+		return { kind: "deleted", ...ownerResultFields() };
 	}
 
 	#verifiedReadAndHeader(
@@ -3085,9 +3483,11 @@ class MemorySessionStorageWriter implements SessionStorageBufferedWriter {
 		this.#length = nextLength;
 	}
 
+	// Memory storage retains this view, so expose only visible bytes, never capacity.
+	// Appends write after each published prefix; growth switches backing buffers.
 	#writeCurrent(bytesWritten: number): void {
 		this.#writeCalls++;
-		this.#storage.writeBytesOwnedSync(this.#path, Buffer.from(this.#bytes.subarray(0, this.#length)));
+		this.#storage.writeBytesOwnedSync(this.#path, this.#bytes.subarray(0, this.#length));
 		this.#bytesWritten += bytesWritten;
 	}
 
@@ -3103,7 +3503,7 @@ class MemorySessionStorageWriter implements SessionStorageBufferedWriter {
 		}
 		this.#buffer.copy(this.#bytes, this.#length, 0, pendingBytes);
 		this.#writeCalls++;
-		this.#storage.writeBytesOwnedSync(this.#path, Buffer.from(this.#bytes.subarray(0, nextLength)));
+		this.#storage.writeBytesOwnedSync(this.#path, this.#bytes.subarray(0, nextLength));
 		this.#length = nextLength;
 		this.#bufferedBytes = 0;
 		this.#bytesWritten += pendingBytes;
@@ -3453,6 +3853,23 @@ export class MemorySessionStorage implements SessionStorage {
 				new SessionDeleteVerificationError("containment", "Transcript is outside the sessions root"),
 			);
 		}
+		if (
+			[
+				target.taskArtifactOwnerStorageContext,
+				target.taskArtifactOwnerDeletionEvidence,
+				target.taskArtifactOwnerRetirementOutcome,
+				target.taskArtifactOwnerTranscriptDeleted,
+				target.deferTaskArtifactOwnerRetirement,
+				target.taskArtifactOwnerRetired,
+				target.taskArtifactOwnerRetirementContinuation,
+				target.taskArtifactOwnerPayloadRetired,
+				target.taskArtifactOwnerNamespaceRetained,
+			].some(value => value !== undefined)
+		) {
+			return Promise.reject(
+				new SessionDeleteVerificationError("artifacts", "task_artifact_owner_memory_backend_unsupported"),
+			);
+		}
 		const entry = this.#files.get(transcriptPath);
 		if (!entry) return Promise.resolve({ kind: "deleted" });
 		const snapshot = this.readSnapshotSync(transcriptPath);
@@ -3485,6 +3902,21 @@ export class MemorySessionStorage implements SessionStorage {
 		if (path.resolve(header.cwd) !== path.resolve(cwd)) {
 			return Promise.reject(new SessionDeleteVerificationError("cwd", "Transcript header cwd mismatch"));
 		}
+		let ownerLocator: TaskArtifactOwnerLocator | undefined;
+		try {
+			ownerLocator = taskArtifactOwnerLocatorFromTranscriptBytes(snapshot.bytes, sessionId);
+		} catch (error) {
+			return Promise.reject(
+				new SessionDeleteVerificationError("artifacts", "task_artifact_owner_memory_backend_unsupported", {
+					cause: toError(error),
+				}),
+			);
+		}
+		if (ownerLocator) {
+			return Promise.reject(
+				new SessionDeleteVerificationError("artifacts", "task_artifact_owner_memory_backend_unsupported"),
+			);
+		}
 		// Compatible artifact semantics: the memory backend models no directories, so
 		// a key at the artifact path is a non-directory sibling that must fail closed
 		// rather than be silently treated as an absent artifacts directory.