@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/sdk/broker/lifecycle.ts

@@ -3,7 +3,9 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import { getSessionsDir, resolveEquivalentPath } from "@gajae-code/utils";
+import type { NativeExactUnlinkResult } from "@gajae-code/natives";
+import * as native from "@gajae-code/natives";
+import { resolveEquivalentPath } from "@gajae-code/utils";
 
 import {
 	ensureLaunchWorktree,
@@ -11,18 +13,25 @@ import {
 	type GjcLaunchWorktreePlan,
 	planLaunchWorktree,
 } from "../../gjc-runtime/launch-worktree";
-
-import { SessionManager } from "../../session/session-manager";
+import { validateManagedArtifactTree } from "../../session/internal/managed-session-storage";
 import {
 	FileSessionStorage,
 	SessionDeleteVerificationError,
+	type SessionStorageFileIdentity,
+	type SessionStorageSnapshot,
+	type VerifiedSessionDeleteResult,
 	type VerifiedSessionDeleteTarget,
 } from "../../session/session-storage";
 import { SdkClient, SdkClientError } from "../client/client";
+import {
+	type LogicalSessionCandidate,
+	listManagedSessionCandidates,
+	type ManagedSessionScope,
+	resolveManagedSessionScope,
+} from "../session-directory";
 import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
-
-import type { Broker, BrokerCleanupEvidence, BrokerResponse } from "./broker";
-
+import type { Broker, BrokerCleanupEvidence, BrokerCleanupIdentity, BrokerResponse } from "./broker";
+import { decodeLifecycleUtf8, parseLifecycleJson } from "./lifecycle-codec";
 import type {
 	LifecycleCleanupProof,
 	LifecycleDurableEffectsReceipt,
@@ -51,6 +60,9 @@ const MAX_READY_TIMEOUT_MS = 60_000;
 const POLL_MS = 50;
 const CLOSE_TIMEOUT_MS = 2_000;
 const MAX_RECEIVED_AT_SKEW_MS = 5_000;
+const MAX_LIFECYCLE_METADATA_BYTES = 4096;
+const MAX_EFFECT_MARKER_LENGTH = 128;
+const MAX_PROCESS_INCARNATION_LENGTH = 256;
 
 export interface LifecycleDeadlines {
 	receivedAt: number;
@@ -101,6 +113,13 @@ const lifecycleTimingsForTest = new WeakMap<Broker, LifecycleTiming>();
 type LifecycleCommand = SdkInternalSpawnCommand | { file: string; args: string[] };
 type LifecycleCommandResolver = () => LifecycleCommand;
 const lifecycleCommandResolversForTest = new WeakMap<Broker, LifecycleCommandResolver>();
+const lifecycleCleanupHooksForTest = new WeakMap<Broker, () => void>();
+
+/** Test-only hook for simulating a crash immediately after one exact lifecycle detach. */
+export function setLifecycleCleanupHookForTest(broker: Broker, hook: (() => void) | undefined): void {
+	if (hook) lifecycleCleanupHooksForTest.set(broker, hook);
+	else lifecycleCleanupHooksForTest.delete(broker);
+}
 
 export function setLifecycleCommandResolverForTest(
 	broker: Broker,
@@ -172,6 +191,7 @@ export interface SessionLifecycleTranscriptIdentity {
 	size: number;
 	mtimeMs: number;
 	mtimeNs: string;
+	sha256: string;
 }
 
 export interface SessionLifecycleLaunchRequest {
@@ -211,7 +231,9 @@ function isSessionLifecycleTranscriptIdentity(value: unknown): value is SessionL
 		Number.isFinite(identity.mtimeMs) &&
 		identity.mtimeMs >= 0 &&
 		typeof identity.mtimeNs === "string" &&
-		/^\d+$/.test(identity.mtimeNs)
+		/^\d+$/.test(identity.mtimeNs) &&
+		typeof identity.sha256 === "string" &&
+		/^[a-f0-9]{64}$/.test(identity.sha256)
 	);
 }
 
@@ -286,6 +308,23 @@ type SessionLaunch = {
 };
 
 type CleanupEvidence = BrokerCleanupEvidence;
+type CleanupIdentity = {
+	dev: bigint;
+	ino: bigint;
+	size: number;
+	mtimeNs: bigint;
+	sha256: string;
+};
+
+function serializeCleanupIdentity(identity: CleanupIdentity): BrokerCleanupIdentity {
+	return {
+		dev: identity.dev.toString(),
+		ino: identity.ino.toString(),
+		size: identity.size,
+		mtimeNs: identity.mtimeNs.toString(),
+		sha256: identity.sha256,
+	};
+}
 
 const fail = (code: string, message: string, cleanup?: CleanupEvidence): BrokerResponse => ({
 	ok: false,
@@ -384,6 +423,7 @@ type ResumeScope = {
 		size: number;
 		mtimeMs: number;
 		mtimeNs: bigint;
+		sha256: string;
 	};
 };
 function sameResumeLocator(record: LiveResumeRecord, cwd: string, root: string): boolean {
@@ -399,7 +439,8 @@ function sameResumeSessionIdentity(left: ResumeScope, right: ResumeScope): boole
 		left.sessionIdentity.ino === right.sessionIdentity.ino &&
 		left.sessionIdentity.size === right.sessionIdentity.size &&
 		left.sessionIdentity.mtimeMs === right.sessionIdentity.mtimeMs &&
-		left.sessionIdentity.mtimeNs === right.sessionIdentity.mtimeNs
+		left.sessionIdentity.mtimeNs === right.sessionIdentity.mtimeNs &&
+		left.sessionIdentity.sha256 === right.sessionIdentity.sha256
 	);
 }
 function sameLiveResumeRecord(expected: LiveResumeRecord, current: LiveResumeRecord): boolean {
@@ -424,6 +465,7 @@ function serializeTranscriptIdentity(identity: {
 	size: number;
 	mtimeMs: number;
 	mtimeNs: bigint;
+	sha256: string;
 }): SessionLifecycleTranscriptIdentity {
 	return {
 		dev: identity.dev.toString(),
@@ -431,32 +473,56 @@ function serializeTranscriptIdentity(identity: {
 		size: identity.size,
 		mtimeMs: identity.mtimeMs,
 		mtimeNs: identity.mtimeNs.toString(),
+		sha256: identity.sha256,
 	};
 }
+async function managedCandidates(
+	broker: Broker,
+	cwd: string,
+	label: "Saved" | "Source",
+): Promise<
+	| {
+			candidates: readonly LogicalSessionCandidate[];
+			migrationPolicy: "copy-retain" | "disabled";
+			scope: ManagedSessionScope;
+	  }
+	| BrokerResponse
+> {
+	const resolved = await resolveManagedSessionScope({ cwd, agentDir: broker.settings.agentDir });
+	if (resolved.kind !== "resolved")
+		return fail("invalid_input", `${label} session scope is invalid: ${resolved.message}`);
+	const migration = await broker.settings.resolveDirectoryMigration(cwd);
+	if (migration !== "copy-retain" && migration !== "disabled")
+		return fail("invalid_input", "Broker directory migration policy is invalid.");
+	const listed = await listManagedSessionCandidates({ scope: resolved.scope });
+	if (listed.kind !== "complete")
+		return fail("invalid_input", `${label} session storage could not be verified for the requested workspace.`);
+	return { candidates: listed.owned, migrationPolicy: migration, scope: resolved.scope };
+}
 
-function validateSavedTranscript(
+async function validateSavedTranscript(
 	broker: Broker,
 	cwd: string,
 	suppliedPath: string | undefined,
 	expectedSessionId: string | undefined,
 	label: "Saved" | "Source",
-): ValidatedTranscript | BrokerResponse {
-	const inventory = SessionManager.inventorySessionsStrict(cwd, {
-		sessionDir: SessionManager.getDefaultSessionDir(cwd, broker.settings.agentDir),
-	});
-	if (inventory.kind !== "complete")
-		return fail("invalid_input", `${label} session storage could not be verified for the requested workspace.`);
+): Promise<ValidatedTranscript | BrokerResponse> {
+	const inventory = await managedCandidates(broker, cwd, label);
+	if ("ok" in inventory) return inventory;
 	const canonicalPath = suppliedPath ? path.resolve(suppliedPath) : undefined;
 	const matches = inventory.candidates.filter(
 		candidate =>
 			(canonicalPath === undefined || candidate.path === canonicalPath) &&
-			(expectedSessionId === undefined || candidate.id === expectedSessionId),
+			(expectedSessionId === undefined || candidate.sessionId === expectedSessionId),
 	);
-	if (matches.length !== 1 || !isCanonicalSessionId(matches[0]!.id))
+	if (matches.length !== 1 || !isCanonicalSessionId(matches[0]!.sessionId))
 		return fail("invalid_input", `${label} saved session does not match the requested workspace and session id.`);
 	const match = matches[0]!;
-	return { path: match.path, id: match.id, identity: serializeTranscriptIdentity(match.identity) };
+	if (inventory.migrationPolicy === "disabled" && match.provenance === "legacy")
+		return fail("legacy_migration_disabled", `${label} legacy session migration is disabled for this workspace.`);
+	return { path: match.path, id: match.sessionId, identity: serializeTranscriptIdentity(match.identity) };
 }
+
 async function validateLiveResumeScope(
 	broker: Broker,
 	input: Input,
@@ -499,18 +565,18 @@ async function validateLiveResumeScope(
 		return fail("endpoint_stale", "Live session does not match the requested resume scope.");
 	const sessionPath = text(input.sessionPath);
 	if (!sessionPath) return fail("invalid_input", "sessionPath is required to resume a saved session.");
-	const inventory = SessionManager.inventorySessionsStrict(cwd, {
-		sessionDir: SessionManager.getDefaultSessionDir(cwd, broker.settings.agentDir),
-	});
-	if (inventory.kind !== "complete")
+	const inventory = await managedCandidates(broker, cwd, "Saved");
+	if ("ok" in inventory)
 		return fail("endpoint_stale", "Requested saved session could not be verified for the requested workspace.");
 	const canonicalSessionPath = path.resolve(sessionPath);
 	const matches = inventory.candidates.filter(
-		candidate => candidate.id === requestedSessionId && candidate.path === canonicalSessionPath,
+		candidate => candidate.sessionId === requestedSessionId && candidate.path === canonicalSessionPath,
 	);
 	if (matches.length !== 1)
 		return fail("endpoint_stale", "Requested saved session does not match the live session scope.");
 	const session = matches[0]!;
+	if (inventory.migrationPolicy === "disabled" && matches[0]!.provenance === "legacy")
+		return fail("legacy_migration_disabled", "Saved legacy session migration is disabled for this workspace.");
 	return {
 		cwd,
 		stateRoot: root,
@@ -609,15 +675,25 @@ function hasObservedProcessExit(pid: number): boolean {
 
 function isEffectMarker(value: unknown): value is EffectMarker {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const marker = value as Partial<EffectMarker>;
+	const marker = value as Record<string, unknown>;
 	return (
 		typeof marker.pid === "number" &&
 		Number.isSafeInteger(marker.pid) &&
 		marker.pid > 0 &&
 		typeof marker.effectMarker === "string" &&
-		marker.effectMarker.length > 0 &&
+		/^[A-Za-z0-9._-]+$/.test(marker.effectMarker) &&
+		marker.effectMarker.length <= MAX_EFFECT_MARKER_LENGTH &&
 		typeof marker.incarnation === "string" &&
-		marker.incarnation.length > 0
+		marker.incarnation.length > 0 &&
+		marker.incarnation.length <= MAX_PROCESS_INCARNATION_LENGTH
+	);
+}
+
+function isExactEffectMarker(value: unknown): value is EffectMarker {
+	return (
+		isEffectMarker(value) &&
+		Object.keys(value).length === 3 &&
+		Object.keys(value).every(key => key === "pid" || key === "effectMarker" || key === "incarnation")
 	);
 }
 
@@ -627,8 +703,10 @@ function sameEffectMarker(left: EffectMarker, right: EffectMarker): boolean {
 
 async function readEffectMarker(file: string): Promise<EffectMarker | undefined> {
 	try {
-		const marker: unknown = JSON.parse(await fs.readFile(file, "utf8"));
-		return isEffectMarker(marker) ? marker : undefined;
+		const captured = captureLifecycleFile(file, true, true);
+		if (!captured) return undefined;
+		const marker: unknown = parseLifecycleJson(captured.bytes);
+		return isExactEffectMarker(marker) ? marker : undefined;
 	} catch {
 		return undefined;
 	}
@@ -711,7 +789,8 @@ function isLifecycleTranscriptEvidence(value: unknown): value is LifecycleTransc
 		Object.keys(record).length === 2 &&
 		typeof record.digest === "string" &&
 		/^[a-f0-9]{64}$/.test(record.digest) &&
-		isSessionLifecycleTranscriptIdentity(record.identity)
+		isSessionLifecycleTranscriptIdentity(record.identity) &&
+		record.digest === record.identity.sha256
 	);
 }
 
@@ -767,6 +846,10 @@ export async function writeSessionLifecycleFailure(
 ): Promise<void> {
 	if (!isSdkStartupFailure(failure))
 		throw new Error("Lifecycle startup failure does not satisfy the canonical failure contract.");
+	if (transcript && !isLifecycleTranscriptEvidence(transcript))
+		throw new Error(
+			"Lifecycle startup failure transcript evidence does not bind its content digest to its identity.",
+		);
 
 	const incarnation = ownerIncarnation ?? processIncarnation(process.pid);
 	if (!incarnation) return;
@@ -814,24 +897,43 @@ export async function writeSessionLifecycleFailure(
 async function readLifecycleFailureArtifact(
 	file: string,
 	expected: EffectMarker,
-): Promise<{ artifact: LifecycleFailureArtifact; bytes: Buffer; digest: string } | undefined> {
+): Promise<
+	| {
+			artifact: LifecycleFailureArtifact;
+			bytes: Buffer;
+			digest: string;
+			identity: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; sha256: string };
+	  }
+	| undefined
+> {
 	let handle: fs.FileHandle | undefined;
 	try {
 		handle = await fs.open(file, fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW);
-		const stat = await handle.stat();
-		if (!stat.isFile() || stat.size > 4096) return undefined;
-		const bytes = Buffer.alloc(stat.size + 1);
+		const stat = await handle.stat({ bigint: true });
+		if (!stat.isFile() || stat.size > 4096n) return undefined;
+		const bytes = Buffer.alloc(Number(stat.size) + 1);
 		const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
 		if (bytesRead > 4096) return undefined;
 		const raw = bytes.subarray(0, bytesRead);
-		const value: unknown = JSON.parse(raw.toString("utf8"));
+		const value: unknown = parseLifecycleJson(raw);
 		if (
 			!isLifecycleFailureArtifact(value) ||
 			!sameEffectMarker(value, expected) ||
-			canonicalJson(value) !== raw.toString("utf8")
+			canonicalJson(value) !== decodeLifecycleUtf8(raw)
 		)
 			return undefined;
-		return { artifact: value, bytes: raw, digest: createHash("sha256").update(raw).digest("hex") };
+		return {
+			artifact: value,
+			bytes: raw,
+			digest: createHash("sha256").update(raw).digest("hex"),
+			identity: {
+				dev: stat.dev,
+				ino: stat.ino,
+				size: stat.size,
+				mtimeNs: stat.mtimeNs,
+				sha256: createHash("sha256").update(raw).digest("hex"),
+			},
+		};
 	} catch {
 		return undefined;
 	} finally {
@@ -839,6 +941,721 @@ async function readLifecycleFailureArtifact(
 	}
 }
 
+function exactUnlinkLifecycleFile(
+	file: string,
+	identity: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; sha256: string },
+	plannedPath: string,
+): NativeExactUnlinkResult {
+	return native.exactUnlink(file, { ...identity, quarantineName: path.basename(plannedPath) });
+}
+
+type LifecycleCleanupFile = NonNullable<BrokerCleanupEvidence["lifecycleFiles"]>[number];
+
+function sameLifecycleCleanupIdentity(
+	left: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; sha256: string },
+	right: BrokerCleanupIdentity,
+): boolean {
+	return (
+		left.dev.toString() === right.dev &&
+		left.ino.toString() === right.ino &&
+		left.size === BigInt(right.size) &&
+		left.mtimeNs.toString() === right.mtimeNs &&
+		left.sha256 === right.sha256
+	);
+}
+
+function lifecycleCleanupPlan(
+	root: string,
+	id: string,
+	expected: EffectMarker,
+	evidence: { identity: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; sha256: string } },
+): CleanupEvidence {
+	const directory = path.join(root, "sdk");
+	const candidates = [
+		lifecycleFailurePath(root, id, expected.effectMarker),
+		path.join(directory, `${id}.json`),
+		lifecycleReadyPath(root, id),
+		lifecycleMarkerPath(root, id),
+	];
+	const files: LifecycleCleanupFile[] = candidates.flatMap(file => {
+		const captured = captureLifecycleFile(
+			file,
+			true,
+			file === lifecycleMarkerPath(root, id) || file === lifecycleReadyPath(root, id),
+		);
+
+		if (!captured) return [];
+		if (file === lifecycleMarkerPath(root, id) || file === lifecycleReadyPath(root, id)) {
+			let marker: unknown;
+			try {
+				marker = parseLifecycleJson(captured.bytes);
+			} catch {
+				throw new Error("Lifecycle marker changed before cleanup intent persistence.");
+			}
+			if (!isExactEffectMarker(marker) || !sameEffectMarker(marker, expected))
+				throw new Error("Lifecycle marker changed before cleanup intent persistence.");
+		}
+		if (file.endsWith(`${id}.json`)) {
+			let endpoint: { pid?: unknown };
+			try {
+				endpoint = parseLifecycleJson(captured.bytes) as { pid?: unknown };
+			} catch {
+				throw new Error("Lifecycle endpoint changed before cleanup intent persistence.");
+			}
+			if (endpoint.pid !== expected.pid)
+				throw new Error("Lifecycle endpoint changed before cleanup intent persistence.");
+		}
+		const identity = file === candidates[0] ? evidence.identity : captured.identity;
+		if (
+			file === candidates[0] &&
+			!sameLifecycleCleanupIdentity(
+				captured.identity,
+				serializeCleanupIdentity({ ...identity, size: Number(identity.size) }),
+			)
+		)
+			throw new Error("Lifecycle failure artifact changed before cleanup intent persistence.");
+		const attempt = 1;
+		const suffix = randomUUID();
+		return [
+			{
+				path: file,
+				identity: serializeCleanupIdentity({ ...identity, size: Number(identity.size) }),
+				attempt,
+				plannedPath: path.join(directory, `.gjc-delete-${suffix}-${path.basename(file)}`),
+			},
+		];
+	});
+	return { phase: "lifecycle", sessionId: id, metadataRoot: root, lifecycleFiles: files };
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function isCanonicalLifecycleCleanupOriginal(root: string, id: string, original: string): boolean {
+	const directory = path.join(path.resolve(root), "sdk");
+	if (path.dirname(original) !== directory) return false;
+	const basename = path.basename(original);
+	return (
+		basename === `${id}.json` ||
+		basename === `${id}.lifecycle.json` ||
+		basename === `${id}.lifecycle.ready.json` ||
+		new RegExp(`^${escapeRegExp(id)}\\.lifecycle\\.failure\\.[A-Za-z0-9._-]{1,128}\\.json$`).test(basename)
+	);
+}
+
+function lifecycleCleanupHasMixedMetadataSchema(cleanup: CleanupEvidence): boolean {
+	return [
+		cleanup.metadataIdentity,
+		cleanup.metadataPath,
+		cleanup.metadataAttempt,
+		cleanup.plannedMetadataPath,
+		cleanup.detachedMetadataPath,
+		cleanup.metadataCompleted,
+	].some(value => value !== undefined);
+}
+
+function isCleanupIdentity(value: unknown): value is BrokerCleanupIdentity {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const identity = value as Record<string, unknown>;
+	return (
+		Object.keys(identity).length === 5 &&
+		Object.keys(identity).every(
+			key => key === "dev" || key === "ino" || key === "size" || key === "mtimeNs" || key === "sha256",
+		) &&
+		typeof identity.dev === "string" &&
+		/^\d+$/.test(identity.dev) &&
+		typeof identity.ino === "string" &&
+		/^\d+$/.test(identity.ino) &&
+		typeof identity.size === "number" &&
+		Number.isSafeInteger(identity.size) &&
+		identity.size >= 0 &&
+		typeof identity.mtimeNs === "string" &&
+		/^\d+$/.test(identity.mtimeNs) &&
+		typeof identity.sha256 === "string" &&
+		/^[a-f0-9]{64}$/.test(identity.sha256)
+	);
+}
+
+function isLifecycleCleanupFile(value: unknown): value is LifecycleCleanupFile {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const file = value as Record<string, unknown>;
+	const allowed = new Set(["path", "identity", "attempt", "plannedPath", "detachedPath", "completed"]);
+	return (
+		Object.keys(file).every(key => allowed.has(key)) &&
+		typeof file.path === "string" &&
+		file.path.length > 0 &&
+		typeof file.plannedPath === "string" &&
+		file.plannedPath.length > 0 &&
+		isCleanupIdentity(file.identity) &&
+		typeof file.attempt === "number" &&
+		Number.isSafeInteger(file.attempt) &&
+		file.attempt > 0 &&
+		(file.detachedPath === undefined || (typeof file.detachedPath === "string" && file.detachedPath.length > 0)) &&
+		(file.completed === undefined || file.completed === true)
+	);
+}
+
+function isLifecycleCleanupEvidence(cleanup: CleanupEvidence): boolean {
+	if (typeof cleanup !== "object" || cleanup === null || Array.isArray(cleanup)) return false;
+	const record = cleanup as Record<string, unknown>;
+	const allowed = new Set(["phase", "sessionId", "metadataRoot", "lifecycleDeleteMetadata", "lifecycleFiles"]);
+	return (
+		Object.keys(record).every(key => allowed.has(key)) &&
+		record.phase === "lifecycle" &&
+		typeof record.sessionId === "string" &&
+		isCanonicalSessionId(record.sessionId) &&
+		typeof record.metadataRoot === "string" &&
+		record.metadataRoot.length > 0 &&
+		Array.isArray(record.lifecycleFiles) &&
+		record.lifecycleFiles.length > 0 &&
+		record.lifecycleFiles.length <= 4 &&
+		(record.lifecycleDeleteMetadata === undefined || record.lifecycleDeleteMetadata === true) &&
+		record.lifecycleFiles.every(isLifecycleCleanupFile)
+	);
+}
+
+function validateLifecycleCleanupShape(cleanup: CleanupEvidence): BrokerResponse | undefined {
+	if (
+		!isLifecycleCleanupEvidence(cleanup) ||
+		lifecycleCleanupHasMixedMetadataSchema(cleanup) ||
+		(cleanup.lifecycleDeleteMetadata === true && cleanup.lifecycleFiles!.length > 2)
+	)
+		return fail("terminal_uncertain", "Lifecycle cleanup replay lacks a complete unambiguous schema.");
+	const files = cleanup.lifecycleFiles!;
+	const paths = new Set<string>();
+	for (const file of files) {
+		if (!validateLifecycleCleanupFile(cleanup.metadataRoot!, cleanup.sessionId!, file))
+			return fail("terminal_uncertain", "Lifecycle cleanup replay contains an invalid path authority.");
+		const entryPaths = new Map<string, "path" | "plannedPath" | "detachedPath">();
+		for (const [field, candidate] of [
+			["path", file.path],
+			["plannedPath", file.plannedPath],
+			["detachedPath", file.detachedPath],
+		] as const) {
+			if (candidate === undefined) continue;
+			const resolved = path.resolve(candidate);
+			const previousField = entryPaths.get(resolved);
+			if (previousField !== undefined) {
+				if (
+					(previousField === "plannedPath" && field === "detachedPath") ||
+					(previousField === "detachedPath" && field === "plannedPath")
+				)
+					continue;
+				return fail("terminal_uncertain", "Lifecycle cleanup replay contains duplicate path authority.");
+			}
+			entryPaths.set(resolved, field);
+			if (paths.has(resolved))
+				return fail("terminal_uncertain", "Lifecycle cleanup replay contains duplicate path authority.");
+			paths.add(resolved);
+		}
+	}
+	return undefined;
+}
+
+function validateLifecycleCleanupFile(root: string, id: string, file: LifecycleCleanupFile): boolean {
+	const directory = path.join(path.resolve(root), "sdk");
+	const original = path.resolve(file.path);
+	const planned = path.resolve(file.plannedPath);
+	if (
+		!isCanonicalLifecycleCleanupOriginal(root, id, original) ||
+		path.dirname(planned) !== directory ||
+		!path.basename(planned).startsWith(".gjc-delete-") ||
+		(file.detachedPath !== undefined && path.dirname(path.resolve(file.detachedPath)) !== directory)
+	)
+		return false;
+	return isCleanupIdentity(file.identity);
+}
+
+function lifecycleCleanupCandidates(file: LifecycleCleanupFile): string[] {
+	return [file.path, file.detachedPath, file.plannedPath].filter(
+		(value, index, values): value is string => typeof value === "string" && values.indexOf(value) === index,
+	);
+}
+
+function lifecycleMetadataReplayFiles(cleanup: CleanupEvidence): LifecycleCleanupFile[] | undefined {
+	if (cleanup.lifecycleDeleteMetadata !== true) return undefined;
+	return cleanup.lifecycleFiles?.length ? cleanup.lifecycleFiles : undefined;
+}
+
+function absentLifecyclePath(file: string): boolean {
+	try {
+		fsSync.lstatSync(file);
+		return false;
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "ENOENT";
+	}
+}
+
+function isLifecycleCleanupResponse(value: LifecycleFileCapture | BrokerResponse | undefined): value is BrokerResponse {
+	return typeof value === "object" && value !== null && "ok" in value;
+}
+
+function validateLifecycleMetadataReplay(cleanup: CleanupEvidence): BrokerResponse | undefined {
+	const files = lifecycleMetadataReplayFiles(cleanup);
+	if (!files) return undefined;
+	const root = path.resolve(cleanup.metadataRoot!);
+	const id = cleanup.sessionId!;
+	const markerPath = lifecycleMarkerPath(root, id);
+	const readyPath = lifecycleReadyPath(root, id);
+	const authorities = new Set<string>();
+	const candidates = new Set<string>();
+	for (const file of files) {
+		const authority = path.resolve(file.path);
+		if ((authority !== markerPath && authority !== readyPath) || authorities.has(authority))
+			return fail("terminal_uncertain", "Lifecycle metadata replay contains duplicate or non-canonical authority.");
+		authorities.add(authority);
+		for (const candidate of lifecycleCleanupCandidates(file)) {
+			const resolved = path.resolve(candidate);
+			if (candidates.has(resolved))
+				return fail("terminal_uncertain", "Lifecycle metadata replay contains duplicate candidate authority.");
+			candidates.add(resolved);
+		}
+	}
+	const markerEntry = files.find(file => path.resolve(file.path) === markerPath);
+	const readyEntry = files.find(file => path.resolve(file.path) === readyPath);
+	const capture = (file: string): LifecycleFileCapture | undefined | BrokerResponse => {
+		try {
+			return captureLifecycleFile(file, true, true);
+		} catch {
+			return fail("terminal_uncertain", "Lifecycle metadata sibling could not be safely inspected.");
+		}
+	};
+	const marker = capture(markerPath);
+	const ready = capture(readyPath);
+	if (isLifecycleCleanupResponse(marker)) return marker;
+	if (isLifecycleCleanupResponse(ready)) return ready;
+	if (marker && (!markerEntry || !sameLifecycleCleanupIdentity(marker.identity, markerEntry.identity)))
+		return fail("terminal_uncertain", "Lifecycle marker sibling lacks exact replay authority.");
+	if (ready && (!readyEntry || !sameLifecycleCleanupIdentity(ready.identity, readyEntry.identity)))
+		return fail("terminal_uncertain", "Lifecycle readiness sibling lacks exact replay authority.");
+	for (const file of files) {
+		let activeCandidates = 0;
+		for (const candidate of lifecycleCleanupCandidates(file)) {
+			let current: LifecycleFileCapture | undefined;
+			try {
+				current = captureLifecycleFile(candidate, true, true);
+			} catch {
+				return fail("terminal_uncertain", "Lifecycle metadata candidate could not be safely inspected.");
+			}
+			if (!current) continue;
+			if (!sameLifecycleCleanupIdentity(current.identity, file.identity))
+				return fail("terminal_uncertain", "Lifecycle metadata candidate lacks exact replay authority.");
+			activeCandidates++;
+		}
+		if (file.completed && activeCandidates > 0)
+			return fail(
+				"terminal_uncertain",
+				"Lifecycle cleanup receipt marks a metadata target complete while a candidate remains.",
+			);
+		if (!file.completed && activeCandidates > 1)
+			return fail("terminal_uncertain", "Lifecycle metadata replay has multiple active candidates.");
+	}
+	if (ready && !markerEntry)
+		return fail("terminal_uncertain", "Lifecycle readiness metadata lacks canonical marker authority.");
+	if (!ready) return undefined;
+	let readyMarker: EffectMarker;
+	try {
+		const value: unknown = parseLifecycleJson(ready.bytes);
+		if (!isExactEffectMarker(value)) throw new Error("invalid ready marker");
+
+		readyMarker = value;
+	} catch {
+		return fail("terminal_uncertain", "Lifecycle readiness metadata ownership could not be verified.");
+	}
+	if (!markerEntry)
+		return fail("terminal_uncertain", "Lifecycle readiness metadata lacks canonical marker authority.");
+	if (!marker) {
+		if (createHash("sha256").update(canonicalJson(readyMarker)).digest("hex") !== markerEntry.identity.sha256)
+			return fail(
+				"terminal_uncertain",
+				"Lifecycle readiness metadata is not bound to the completed marker authority.",
+			);
+		return undefined;
+	}
+	try {
+		const value: unknown = parseLifecycleJson(marker.bytes);
+		if (!isExactEffectMarker(value) || !sameEffectMarker(value, readyMarker)) throw new Error("mismatched marker");
+	} catch {
+		return fail("terminal_uncertain", "Lifecycle metadata siblings do not share one owner marker.");
+	}
+	return undefined;
+}
+
+function lifecycleMetadataReplayAbsent(cleanup: CleanupEvidence): boolean {
+	const files = lifecycleMetadataReplayFiles(cleanup);
+	if (!files) return true;
+	const root = path.resolve(cleanup.metadataRoot!);
+	const id = cleanup.sessionId!;
+	const required = new Set<string>([lifecycleMarkerPath(root, id), lifecycleReadyPath(root, id)]);
+	for (const file of files) for (const candidate of lifecycleCleanupCandidates(file)) required.add(candidate);
+	return [...required].every(absentLifecyclePath);
+}
+
+/**
+ * Base dev persisted metadata cleanup one file at a time. Accept only its
+ * identity-bound marker receipt and translate it into the current replay plan.
+ */
+function hasExactLegacyMetadataCleanupKeys(cleanup: CleanupEvidence): boolean {
+	if (typeof cleanup !== "object" || cleanup === null || Array.isArray(cleanup)) return false;
+	const allowed = new Set([
+		"phase",
+		"sessionId",
+		"metadataRoot",
+		"metadataIdentity",
+		"metadataPath",
+		"metadataAttempt",
+		"plannedMetadataPath",
+		"detachedMetadataPath",
+		"metadataCompleted",
+	]);
+	return Object.keys(cleanup as Record<string, unknown>).every(key => allowed.has(key));
+}
+
+function legacyMetadataCleanupPlan(cleanup: CleanupEvidence): CleanupEvidence | undefined {
+	if (
+		!hasExactLegacyMetadataCleanupKeys(cleanup) ||
+		cleanup.phase !== "metadata" ||
+		typeof cleanup.sessionId !== "string" ||
+		!isCanonicalSessionId(cleanup.sessionId) ||
+		typeof cleanup.metadataRoot !== "string" ||
+		cleanup.metadataRoot.length === 0 ||
+		typeof cleanup.metadataPath !== "string" ||
+		cleanup.metadataPath.length === 0 ||
+		!cleanup.metadataIdentity ||
+		typeof cleanup.plannedMetadataPath !== "string" ||
+		cleanup.plannedMetadataPath.length === 0 ||
+		(cleanup.detachedMetadataPath !== undefined &&
+			(typeof cleanup.detachedMetadataPath !== "string" || cleanup.detachedMetadataPath.length === 0)) ||
+		(cleanup.metadataCompleted !== undefined && cleanup.metadataCompleted !== true)
+	)
+		return undefined;
+	const root = path.resolve(cleanup.metadataRoot);
+	const directory = path.join(root, "sdk");
+	const markerPath = lifecycleMarkerPath(root, cleanup.sessionId);
+	const readyPath = lifecycleReadyPath(root, cleanup.sessionId);
+	const metadataPath = path.resolve(cleanup.metadataPath);
+	const plannedPath = path.resolve(cleanup.plannedMetadataPath);
+	const detachedPath = cleanup.detachedMetadataPath && path.resolve(cleanup.detachedMetadataPath);
+	if (
+		metadataPath !== markerPath ||
+		path.dirname(plannedPath) !== directory ||
+		!path.basename(plannedPath).startsWith(".gjc-delete-") ||
+		(detachedPath !== undefined && path.dirname(detachedPath) !== directory) ||
+		(cleanup.metadataAttempt !== undefined &&
+			(!Number.isSafeInteger(cleanup.metadataAttempt) || cleanup.metadataAttempt < 1))
+	)
+		return undefined;
+	const persistedIdentity = cleanupIdentity(cleanup.metadataIdentity);
+	if (!persistedIdentity) return undefined;
+
+	const captureExactRegular = (
+		file: string,
+	): { kind: "absent" } | { kind: "present"; capture: LifecycleFileCapture } | undefined => {
+		try {
+			const stat = fsSync.lstatSync(file);
+			if (stat.isSymbolicLink() || !stat.isFile()) return undefined;
+			const capture = captureLifecycleFile(file, true, true);
+
+			return capture ? { kind: "present", capture } : undefined;
+		} catch (error) {
+			return (error as NodeJS.ErrnoException).code === "ENOENT" ? { kind: "absent" } : undefined;
+		}
+	};
+
+	const markerCandidates = [metadataPath, detachedPath, plannedPath].filter(
+		(candidate, index, candidates): candidate is string =>
+			typeof candidate === "string" && candidates.indexOf(candidate) === index,
+	);
+	let activeMarker: LifecycleFileCapture | undefined;
+	for (const candidate of markerCandidates) {
+		const current = captureExactRegular(candidate);
+		if (!current) return undefined;
+		if (current.kind === "absent") continue;
+		if (!sameLifecycleCleanupIdentity(current.capture.identity, serializeCleanupIdentity(persistedIdentity)))
+			return undefined;
+		if (activeMarker) return undefined;
+		activeMarker = current.capture;
+	}
+	const markerCompleted = !activeMarker;
+	// Legacy receipts can crash after exact marker unlink and before recording metadataCompleted.
+	// With every authorized marker candidate absent, only the persisted marker digest may bind a ready sibling.
+	let marker: EffectMarker | undefined;
+	if (activeMarker) {
+		try {
+			const value: unknown = parseLifecycleJson(activeMarker.bytes);
+			if (!isExactEffectMarker(value)) return undefined;
+
+			marker = value;
+		} catch {
+			return undefined;
+		}
+	}
+
+	const ready = captureExactRegular(readyPath);
+	if (!ready) return undefined;
+	let readyMarker: EffectMarker | undefined;
+	if (ready.kind === "present") {
+		try {
+			const value: unknown = parseLifecycleJson(ready.capture.bytes);
+			if (!isExactEffectMarker(value)) return undefined;
+
+			readyMarker = value;
+		} catch {
+			return undefined;
+		}
+		if (marker && !sameEffectMarker(marker, readyMarker)) return undefined;
+		if (!marker && createHash("sha256").update(canonicalJson(readyMarker)).digest("hex") !== persistedIdentity.sha256)
+			return undefined;
+	}
+
+	return {
+		phase: "lifecycle",
+		sessionId: cleanup.sessionId,
+		metadataRoot: root,
+		lifecycleDeleteMetadata: true,
+		lifecycleFiles: [
+			{
+				path: metadataPath,
+				identity: serializeCleanupIdentity({
+					...(activeMarker?.identity ?? persistedIdentity),
+					size: Number((activeMarker?.identity ?? persistedIdentity).size),
+				}),
+				attempt: cleanup.metadataAttempt ?? 1,
+				plannedPath,
+				...(detachedPath ? { detachedPath } : {}),
+				...(markerCompleted ? { completed: true as const } : {}),
+			},
+			...(ready.kind === "present"
+				? [
+						{
+							path: readyPath,
+							identity: serializeCleanupIdentity({
+								...ready.capture.identity,
+								size: Number(ready.capture.identity.size),
+							}),
+							attempt: 1,
+							plannedPath: path.join(directory, `.gjc-delete-${randomUUID()}-${path.basename(readyPath)}`),
+						},
+					]
+				: []),
+		],
+	};
+}
+
+function lifecycleDeleteMetadataCleanupPlan(
+	metadataRoot: string,
+	id: string,
+	files: ReadonlyArray<{ metadataPath: string; metadata: LifecycleFileCapture }>,
+): CleanupEvidence {
+	return {
+		phase: "lifecycle",
+		sessionId: id,
+		metadataRoot,
+		lifecycleDeleteMetadata: true,
+		lifecycleFiles: files.map(({ metadataPath, metadata }) => ({
+			path: metadataPath,
+			identity: serializeCleanupIdentity({
+				dev: metadata.identity.dev,
+				ino: metadata.identity.ino,
+				size: Number(metadata.identity.size),
+				mtimeNs: metadata.identity.mtimeNs,
+				sha256: metadata.identity.sha256,
+			}),
+			attempt: 1,
+			plannedPath: path.join(
+				path.dirname(metadataPath),
+				`.gjc-delete-${randomUUID()}-${path.basename(metadataPath)}`,
+			),
+		})),
+	};
+}
+
+type LifecycleDeleteMetadataPreflight = { cleanup: CleanupEvidence } | BrokerResponse;
+
+/**
+ * Capture lifecycle metadata before deleting any saved user data. A fresh delete
+ * may only clean metadata owned by one dead lifecycle process.
+ */
+function preflightLifecycleDeleteMetadata(
+	root: string,
+	id: string,
+	record: { pid: number } | undefined,
+	readIncarnation: (pid: number) => string | undefined,
+): LifecycleDeleteMetadataPreflight {
+	const metadataPaths = [lifecycleMarkerPath(root, id), lifecycleReadyPath(root, id)];
+	const lifecycleMetadata: Array<{
+		metadataPath: string;
+		metadata: LifecycleFileCapture;
+		marker: EffectMarker;
+	}> = [];
+	for (const metadataPath of metadataPaths) {
+		let metadata: LifecycleFileCapture | undefined;
+		try {
+			metadata = captureLifecycleFile(metadataPath, true, true);
+		} catch {
+			return fail("terminal_uncertain", "Lifecycle metadata path is occupied by an unsafe object.");
+		}
+		if (!metadata) continue;
+		let marker: unknown;
+		try {
+			marker = parseLifecycleJson(metadata.bytes);
+		} catch {
+			return fail("terminal_uncertain", "Lifecycle metadata ownership could not be verified.");
+		}
+		if (
+			!isExactEffectMarker(marker) ||
+			(record && marker.pid !== record.pid) ||
+			observeProcess(marker.pid, marker.incarnation, readIncarnation) !== "exited"
+		)
+			return fail("terminal_uncertain", "Lifecycle metadata ownership could not be verified.");
+		lifecycleMetadata.push({ metadataPath, metadata, marker });
+	}
+	const canonicalLifecycleMarker = lifecycleMetadata.find(
+		metadata => metadata.metadataPath === lifecycleMarkerPath(root, id),
+	);
+	const lifecycleReadyMarker = lifecycleMetadata.find(
+		metadata => metadata.metadataPath === lifecycleReadyPath(root, id),
+	);
+	if (lifecycleReadyMarker && !canonicalLifecycleMarker)
+		return fail(
+			"terminal_uncertain",
+			"Lifecycle readiness metadata lacks canonical marker authority for fresh cleanup.",
+		);
+	if (
+		canonicalLifecycleMarker &&
+		lifecycleReadyMarker &&
+		!sameEffectMarker(canonicalLifecycleMarker.marker, lifecycleReadyMarker.marker)
+	)
+		return fail("terminal_uncertain", "Lifecycle metadata siblings do not share one owner marker.");
+	return { cleanup: lifecycleDeleteMetadataCleanupPlan(root, id, lifecycleMetadata) };
+}
+
+async function reconcileLifecycleCleanup(
+	broker: Broker,
+	identity: string,
+	cleanup: CleanupEvidence,
+	completion: BrokerResponse = fail("spawn_failed", "No ready SDK endpoint remains available."),
+): Promise<BrokerResponse> {
+	const shapeValidation = validateLifecycleCleanupShape(cleanup);
+	if (shapeValidation) return shapeValidation;
+	let activeCleanup =
+		cleanup.lifecycleDeleteMetadata === true || completion.ok
+			? { ...cleanup, lifecycleDeleteMetadata: true as const }
+			: cleanup;
+	const metadataReplayValidation = validateLifecycleMetadataReplay(activeCleanup);
+	if (metadataReplayValidation) return metadataReplayValidation;
+	for (let index = 0; index < activeCleanup.lifecycleFiles!.length; index++) {
+		const file = activeCleanup.lifecycleFiles![index];
+		if (!validateLifecycleCleanupFile(activeCleanup.metadataRoot!, activeCleanup.sessionId!, file))
+			return fail("terminal_uncertain", "Lifecycle cleanup replay contains an invalid path authority.");
+		const candidates = lifecycleCleanupCandidates(file);
+		if (file.completed) {
+			for (const candidate of candidates) {
+				try {
+					fsSync.lstatSync(candidate);
+					return fail(
+						"terminal_uncertain",
+						"Lifecycle cleanup receipt marks a target complete while an authorized candidate remains.",
+					);
+				} catch (error) {
+					if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+						return fail("terminal_uncertain", "Lifecycle cleanup completion could not be safely inspected.");
+				}
+			}
+			continue;
+		}
+		let activePath: string | undefined;
+		let captured: LifecycleFileCapture | undefined;
+		let foundUnauthorized = false;
+		for (const candidate of candidates) {
+			try {
+				const stat = fsSync.lstatSync(candidate);
+				if (stat.isSymbolicLink() || !stat.isFile()) {
+					foundUnauthorized = true;
+					continue;
+				}
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+				foundUnauthorized = true;
+				continue;
+			}
+			const current = captureLifecycleFile(candidate, true, true);
+
+			if (!current) {
+				foundUnauthorized = true;
+				continue;
+			}
+			if (sameLifecycleCleanupIdentity(current.identity, file.identity) && !activePath) {
+				activePath = candidate;
+				captured = current;
+			} else {
+				foundUnauthorized = true;
+			}
+		}
+		if (foundUnauthorized)
+			return fail("terminal_uncertain", "Lifecycle cleanup target identity changed before reconciliation.");
+		if (!captured || !activePath) {
+			const lifecycleFiles = activeCleanup.lifecycleFiles!.map((candidate, candidateIndex) =>
+				candidateIndex === index ? { ...candidate, completed: true as const } : candidate,
+			);
+			activeCleanup = { ...activeCleanup, lifecycleFiles };
+			await broker.ledger.transition(identity, "effect_started", {
+				response: fail("cleanup_pending", "Lifecycle cleanup completion was durably reconciled.", activeCleanup),
+			});
+			continue;
+		}
+
+		if (file.detachedPath || activePath === file.plannedPath) {
+			const nextFile: LifecycleCleanupFile = {
+				...file,
+				detachedPath: activePath,
+				attempt: (file.attempt ?? 1) + 1,
+				plannedPath: path.join(path.dirname(file.path), `.gjc-delete-${randomUUID()}-${path.basename(file.path)}`),
+			};
+			const lifecycleFiles = activeCleanup.lifecycleFiles!.map((candidate, candidateIndex) =>
+				candidateIndex === index ? nextFile : candidate,
+			);
+			activeCleanup = { ...activeCleanup, lifecycleFiles };
+			await broker.ledger.transition(identity, "effect_started", {
+				response: fail(
+					"cleanup_pending",
+					"Lifecycle retry cleanup is preauthorized for durable reconciliation.",
+					activeCleanup,
+				),
+			});
+		}
+		const currentFile = activeCleanup.lifecycleFiles![index];
+		const result = native.exactUnlink(activePath, {
+			...captured.identity,
+			quarantineName: path.basename(currentFile.plannedPath),
+		});
+		if (!result.ok) {
+			const lifecycleFiles = activeCleanup.lifecycleFiles!.map((candidate, candidateIndex) =>
+				candidateIndex === index && result.detachedPath
+					? { ...candidate, detachedPath: result.detachedPath }
+					: candidate,
+			);
+			return fail("cleanup_pending", `Lifecycle cleanup remains pending: ${result.code ?? "unknown"}`, {
+				...activeCleanup,
+				lifecycleFiles,
+			});
+		}
+		const lifecycleFiles = activeCleanup.lifecycleFiles!.map((candidate, candidateIndex) =>
+			candidateIndex === index ? { ...candidate, completed: true as const } : candidate,
+		);
+		activeCleanup = { ...activeCleanup, lifecycleFiles };
+		await broker.ledger.transition(identity, "effect_started", {
+			response: fail("cleanup_pending", "Lifecycle cleanup completion was durably reconciled.", activeCleanup),
+		});
+		lifecycleCleanupHooksForTest.get(broker)?.();
+	}
+	if (!lifecycleMetadataReplayAbsent(activeCleanup))
+		return fail("terminal_uncertain", "Lifecycle metadata replay left an authorized sibling behind.");
+	await syncDirectory(path.join(activeCleanup.metadataRoot!, "sdk"));
+	return completion;
+}
+
 async function readSessionLifecycleFailure(
 	root: string,
 	id: string,
@@ -882,25 +1699,116 @@ async function hasOwnedReadinessEvidence(
 	);
 }
 
+type LifecycleFileCapture = {
+	bytes: Buffer;
+	identity: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; sha256: string };
+	digest: string;
+};
+
+function captureLifecycleFile(file: string, requireRegular = false, bounded = false): LifecycleFileCapture | undefined {
+	let descriptor: number | undefined;
+	try {
+		const preflight = bounded ? fsSync.lstatSync(file, { bigint: true }) : undefined;
+		if (
+			preflight &&
+			(!preflight.isFile() || preflight.size === 0n || preflight.size > BigInt(MAX_LIFECYCLE_METADATA_BYTES))
+		) {
+			if (requireRegular) throw new Error("Lifecycle metadata is not a bounded regular file.");
+			return undefined;
+		}
+		descriptor = fsSync.openSync(file, fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW);
+		const stat = fsSync.fstatSync(descriptor, { bigint: true });
+		if (
+			!stat.isFile() ||
+			(bounded &&
+				(stat.size === 0n ||
+					stat.size > BigInt(MAX_LIFECYCLE_METADATA_BYTES) ||
+					!preflight ||
+					stat.dev !== preflight.dev ||
+					stat.ino !== preflight.ino))
+		) {
+			if (requireRegular) throw new Error("Lifecycle cleanup candidate is not an exact bounded regular file.");
+			return undefined;
+		}
+		const bytes = fsSync.readFileSync(descriptor);
+		const current = fsSync.fstatSync(descriptor, { bigint: true });
+		if (
+			!current.isFile() ||
+			current.dev !== stat.dev ||
+			current.ino !== stat.ino ||
+			current.size !== stat.size ||
+			current.mtimeNs !== stat.mtimeNs
+		)
+			return undefined;
+		return {
+			bytes,
+			identity: {
+				dev: stat.dev,
+				ino: stat.ino,
+				size: stat.size,
+				mtimeNs: stat.mtimeNs,
+				sha256: createHash("sha256").update(bytes).digest("hex"),
+			},
+			digest: createHash("sha256").update(bytes).digest("hex"),
+		};
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	} finally {
+		if (descriptor !== undefined) fsSync.closeSync(descriptor);
+	}
+}
+
 async function removeOwnedLifecycleArtifacts(root: string, id: string, expected: EffectMarker): Promise<boolean> {
 	const marker = await readEffectMarker(lifecycleMarkerPath(root, id));
 	if (!marker || !sameEffectMarker(marker, expected)) return false;
 	const endpointPath = path.join(root, "sdk", `${id}.json`);
-	try {
-		const endpoint = JSON.parse(await fs.readFile(endpointPath, "utf8")) as { pid?: unknown };
-		if (endpoint.pid !== expected.pid || !hasObservedProcessExit(expected.pid)) return false;
-		await fs.rm(endpointPath);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") return false;
+	const plannedEndpointPath = path.join(
+		path.dirname(endpointPath),
+		`.gjc-delete-endpoint-${expected.effectMarker}-${path.basename(endpointPath)}`,
+	);
+	const retryEndpointPath = path.join(
+		path.dirname(endpointPath),
+		`.gjc-delete-endpoint-retry-${expected.effectMarker}-${path.basename(endpointPath)}`,
+	);
+	const finalEndpointPath = path.join(
+		path.dirname(endpointPath),
+		`.gjc-delete-endpoint-final-${expected.effectMarker}-${path.basename(endpointPath)}`,
+	);
+	const endpointSource = [endpointPath, plannedEndpointPath, retryEndpointPath, finalEndpointPath].find(candidate => {
+		try {
+			return fsSync.lstatSync(candidate).isFile();
+		} catch {
+			return false;
+		}
+	});
+	const endpoint = endpointSource ? captureLifecycleFile(endpointSource) : undefined;
+	if (endpoint && endpointSource) {
+		let parsed: { pid?: unknown };
+		try {
+			parsed = parseLifecycleJson(endpoint.bytes) as { pid?: unknown };
+		} catch {
+			return false;
+		}
+		if (parsed.pid !== expected.pid || !hasObservedProcessExit(expected.pid)) return false;
+		if (createHash("sha256").update(endpoint.bytes).digest("hex") !== endpoint.digest) return false;
+		const endpointRemoval = exactUnlinkLifecycleFile(
+			endpointSource,
+			endpoint.identity,
+			endpointSource === endpointPath
+				? plannedEndpointPath
+				: endpointSource === plannedEndpointPath
+					? retryEndpointPath
+					: finalEndpointPath,
+		);
+		if (!endpointRemoval.ok) return false;
 	}
-	if (!(await endpointRemoved(root, id))) return false;
 	const currentMarker = await readEffectMarker(lifecycleMarkerPath(root, id));
 	if (!currentMarker || !sameEffectMarker(currentMarker, expected)) return false;
-	try {
-		await fs.rm(lifecycleReadyPath(root, id), { force: true });
-	} catch {
-		return false;
-	}
+	const readyPath = lifecycleReadyPath(root, id);
+	const ready = captureLifecycleFile(readyPath, true, true);
+	if (ready && createHash("sha256").update(ready.bytes).digest("hex") !== ready.digest) return false;
+	// Readiness mutation is deferred to the same ledger-backed cleanup transaction.
 	return true;
 }
 
@@ -1019,7 +1927,7 @@ async function terminateSpawnedChild(
 		expected &&
 		!broker.index.hasHostRegistrationForLifecycle(id, pid, expected.effectMarker)
 	)
-		return endpointRemoved(root, id);
+		return true;
 	const registeredBeforeTermination =
 		rollbackGeneration === undefined || rollbackGeneration === null
 			? undefined
@@ -1291,7 +2199,7 @@ async function launchInput(
 		if (!requested) return fail("invalid_input", "sessionId is required to resume a saved session.");
 		const savedPath = text(input.sessionPath);
 		if (!savedPath) return fail("invalid_input", "sessionPath is required to resume a saved session.");
-		const saved = validateSavedTranscript(broker, cwd, savedPath, requested, "Saved");
+		const saved = await validateSavedTranscript(broker, cwd, savedPath, requested, "Saved");
 		if ("ok" in saved) return saved;
 		return {
 			id: requested,
@@ -1310,7 +2218,7 @@ async function launchInput(
 	const sourceSessionPath = text(input.sourceSessionPath) ?? text(input.sourcePath) ?? text(input.sessionPath);
 	if (!sourceSessionId && !sourceSessionPath)
 		return fail("invalid_input", "sourceSessionId or sourceSessionPath is required to fork a session.");
-	const source = validateSavedTranscript(broker, sourceCwd, sourceSessionPath, sourceSessionId, "Source");
+	const source = await validateSavedTranscript(broker, sourceCwd, sourceSessionPath, sourceSessionId, "Source");
 	if ("ok" in source) return source;
 	return {
 		id: randomUUID(),
@@ -1326,22 +2234,149 @@ async function launchInput(
 	};
 }
 
-function within(root: string, candidate: string): boolean {
-	const relative = path.relative(root, candidate);
-	return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
-}
 type ValidatedDelete = {
 	storage: FileSessionStorage;
 	target: VerifiedSessionDeleteTarget;
 	metadataRoot: string;
 };
+function cleanupIdentity(
+	identity: BrokerCleanupEvidence["transcriptIdentity"],
+	allowEmptySha256 = false,
+): SessionStorageFileIdentity | undefined {
+	if (
+		!identity ||
+		!/^[0-9]+$/.test(identity.dev) ||
+		!/^[0-9]+$/.test(identity.ino) ||
+		!Number.isSafeInteger(identity.size) ||
+		identity.size < 0 ||
+		!/^[0-9]+$/.test(identity.mtimeNs) ||
+		(!allowEmptySha256 && !/^[a-f0-9]{64}$/.test(identity.sha256)) ||
+		(allowEmptySha256 && identity.sha256 !== "" && !/^[a-f0-9]{64}$/.test(identity.sha256))
+	)
+		return undefined;
+	return {
+		dev: BigInt(identity.dev),
+		ino: BigInt(identity.ino),
+		size: identity.size,
+		mtimeNs: BigInt(identity.mtimeNs),
+		sha256: identity.sha256,
+	};
+}
+
+function replayDeleteTarget(cleanup: CleanupEvidence): ValidatedDelete | BrokerResponse {
+	const transcriptIdentity = cleanupIdentity(cleanup.transcriptIdentity);
+	if (
+		(cleanup.phase !== "artifacts" && cleanup.phase !== "transcript") ||
+		!cleanup.sessionId ||
+		!isCanonicalSessionId(cleanup.sessionId) ||
+		!cleanup.sessionsRoot ||
+		!cleanup.transcriptPath ||
+		!cleanup.cwd ||
+		!cleanup.metadataRoot ||
+		!transcriptIdentity
+	) {
+		return fail("terminal_uncertain", "Cleanup replay lacks a complete ledger-bound deletion target.");
+	}
+	const artifactsIdentity = cleanupIdentity(cleanup.artifactsIdentity, true);
+	const artifactTreeIdentity =
+		cleanup.artifactsRemoved === true || !cleanup.artifactTree
+			? undefined
+			: cleanupIdentity(cleanup.artifactTree.identity, true);
+	if (cleanup.artifactsRemoved !== true && cleanup.artifactTree && !artifactTreeIdentity)
+		return fail("terminal_uncertain", "Artifact tree cleanup lacks its ledger-bound identity.");
+
+	if (cleanup.detachedArtifactsPath && !artifactsIdentity)
+		return fail("terminal_uncertain", "Detached artifact cleanup lacks its ledger-bound identity.");
+	const plannedArtifactsPath = cleanup.plannedArtifactsPath;
+	const plannedTranscriptPath = cleanup.plannedTranscriptPath;
+	if (
+		(plannedArtifactsPath &&
+			(path.dirname(plannedArtifactsPath) !== path.dirname(cleanup.transcriptPath) ||
+				!path.basename(plannedArtifactsPath).startsWith(".gjc-delete-"))) ||
+		(plannedTranscriptPath &&
+			(path.dirname(plannedTranscriptPath) !== path.dirname(cleanup.transcriptPath) ||
+				!path.basename(plannedTranscriptPath).startsWith(".gjc-delete-"))) ||
+		(cleanup.artifactsRemoved !== true &&
+			cleanup.artifactTree &&
+			(path.dirname(cleanup.artifactTree.plannedPath) !== path.dirname(cleanup.transcriptPath) ||
+				!path.basename(cleanup.artifactTree.plannedPath).startsWith(".gjc-delete-") ||
+				(cleanup.artifactTree.detachedPath !== undefined &&
+					path.dirname(cleanup.artifactTree.detachedPath) !== path.dirname(cleanup.transcriptPath))))
+	)
+		return fail("terminal_uncertain", "Cleanup replay has invalid preauthorized quarantine paths.");
+	if (
+		cleanup.phase === "transcript" &&
+		cleanup.artifactsRemoved === true &&
+		![cleanup.transcriptPath, cleanup.detachedTranscriptPath, plannedTranscriptPath].some(
+			candidate => typeof candidate === "string" && fsSync.existsSync(candidate),
+		)
+	)
+		return { ok: true, result: { sessionId: cleanup.sessionId } };
+	const artifactRemovingPath =
+		cleanup.artifactsRemoved === true
+			? undefined
+			: cleanup.artifactTree
+				? `${cleanup.artifactTree.plannedPath}.removing`
+				: plannedArtifactsPath
+					? `${plannedArtifactsPath}.removing`
+					: undefined;
+	const recoveredDetachedArtifactsPath =
+		cleanup.detachedArtifactsPath && fsSync.existsSync(cleanup.detachedArtifactsPath)
+			? cleanup.detachedArtifactsPath
+			: artifactRemovingPath && fsSync.existsSync(artifactRemovingPath)
+				? artifactRemovingPath
+				: plannedArtifactsPath &&
+						!fsSync.existsSync(cleanup.transcriptPath.slice(0, -6)) &&
+						fsSync.existsSync(plannedArtifactsPath)
+					? plannedArtifactsPath
+					: undefined;
+	const recoveredDetachedTranscriptPath =
+		cleanup.detachedTranscriptPath && fsSync.existsSync(cleanup.detachedTranscriptPath)
+			? cleanup.detachedTranscriptPath
+			: plannedTranscriptPath &&
+					!fsSync.existsSync(cleanup.transcriptPath) &&
+					fsSync.existsSync(plannedTranscriptPath)
+				? plannedTranscriptPath
+				: undefined;
+	return {
+		storage: new FileSessionStorage(),
+		target: {
+			sessionsRoot: cleanup.sessionsRoot,
+			transcriptPath: cleanup.transcriptPath,
+			sessionId: cleanup.sessionId,
+			cwd: cleanup.cwd,
+			transcriptIdentity,
+			...(cleanup.artifactsRemoved === true ? { artifactsRemoved: true } : {}),
+			...(cleanup.artifactsRemoved !== true && artifactsIdentity
+				? { expectedArtifactsIdentity: artifactsIdentity }
+				: {}),
+			...(cleanup.artifactsRemoved !== true && recoveredDetachedArtifactsPath
+				? { detachedArtifactsPath: recoveredDetachedArtifactsPath }
+				: {}),
+			...(recoveredDetachedTranscriptPath ? { detachedTranscriptPath: recoveredDetachedTranscriptPath } : {}),
+			...(plannedArtifactsPath ? { plannedArtifactsPath } : {}),
+			...(plannedTranscriptPath ? { plannedTranscriptPath } : {}),
+			...(cleanup.artifactsRemoved !== true && cleanup.artifactTree && artifactTreeIdentity
+				? {
+						expectedArtifactsIdentity: artifactTreeIdentity,
+						expectedArtifactsTree: cleanup.artifactTree.snapshot,
+						detachedArtifactsPath: cleanup.artifactTree.detachedPath ?? recoveredDetachedArtifactsPath,
+						plannedArtifactsPath: cleanup.artifactTree.plannedPath,
+					}
+				: {}),
+		},
+		metadataRoot: cleanup.metadataRoot,
+	};
+}
 
 async function validateDeletePath(
 	broker: Broker,
 	input: Input,
 	id: string,
 	record: { locator: { repo: string; stateRoot: string } } | undefined,
+	cleanup?: CleanupEvidence,
 ): Promise<ValidatedDelete | BrokerResponse> {
+	if (cleanup) return replayDeleteTarget(cleanup);
 	const sessionPath = text(input.sessionPath);
 	const cwd = lifecycleCwd(input);
 	if (!sessionPath || !cwd)
@@ -1355,62 +2390,48 @@ async function validateDeletePath(
 	)
 		return fail("invalid_input", "session.delete locator does not match the indexed session.");
 
-	const unresolved = path.resolve(sessionPath);
-	const storageRoot = await fs
-		.realpath(getSessionsDir(broker.settings.agentDir))
-		.catch(() => path.resolve(getSessionsDir(broker.settings.agentDir)));
-	const canonicalParent = await fs.realpath(path.dirname(unresolved)).catch(() => path.dirname(unresolved));
-	const candidate = path.join(canonicalParent, path.basename(unresolved));
-	if (!candidate.endsWith(".jsonl") || !within(storageRoot, candidate))
-		return fail("invalid_input", "session.delete path is outside the configured session storage root.");
-	try {
-		if ((await fs.lstat(candidate)).isSymbolicLink())
-			return fail("invalid_input", "session.delete path is a symlink.");
-	} catch {
-		return fail("not_found", "Requested saved session does not exist.");
-	}
-	let resolved: string;
-	try {
-		resolved = await fs.realpath(candidate);
-	} catch {
-		return fail("not_found", "Requested saved session does not exist.");
-	}
-	if (!within(storageRoot, resolved))
-		return fail("invalid_input", "session.delete path resolves outside the configured session storage root.");
+	const inventory = await managedCandidates(broker, cwd, "Saved");
+	if ("ok" in inventory) return inventory;
+	const candidatePath = path.resolve(sessionPath);
+	const matches = inventory.candidates.filter(
+		candidate => candidate.path === candidatePath && candidate.sessionId === id,
+	);
+	if (matches.length !== 1)
+		return fail("invalid_input", "session.delete path is not an owned managed session for the configured cwd.");
+	const match = matches[0]!;
+	if (inventory.migrationPolicy === "disabled" && match.provenance === "legacy")
+		return fail("legacy_migration_disabled", "Saved legacy session migration is disabled for this workspace.");
 
 	const storage = new FileSessionStorage();
-	let snapshot: ReturnType<FileSessionStorage["readSnapshotSync"]>;
+	let snapshot: SessionStorageSnapshot;
 	try {
-		snapshot = storage.readSnapshotSync(resolved);
+		snapshot = storage.readSnapshotSync(candidatePath);
 	} catch {
 		return fail("not_found", "Requested saved session does not exist or cannot be read.");
 	}
-	try {
-		const newline = snapshot.bytes.indexOf(0x0a);
-		const firstLine = Buffer.from(
-			snapshot.bytes.subarray(0, newline === -1 ? snapshot.bytes.length : newline),
-		).toString("utf8");
-		const header = JSON.parse(firstLine) as { type?: unknown; id?: unknown; cwd?: unknown };
-		if (header.type !== "session" || header.id !== id)
-			return fail("invalid_input", "session.delete path does not contain the requested session.");
-		if (typeof header.cwd !== "string")
-			return fail("invalid_input", "session.delete transcript cwd does not match the configured cwd.");
-		const transcriptCwd = header.cwd;
-		const headerCwd = await fs.realpath(transcriptCwd).catch(() => path.resolve(transcriptCwd));
-		const requestedCwd = await fs.realpath(cwd).catch(() => cwd);
-		if (headerCwd !== requestedCwd)
-			return fail("invalid_input", "session.delete transcript cwd does not match the configured cwd.");
-	} catch {
-		return fail("invalid_input", "Requested saved session has an invalid header.");
-	}
+	const digest = createHash("sha256").update(snapshot.bytes).digest("hex");
+	if (
+		snapshot.stat.dev !== match.identity.dev ||
+		snapshot.stat.ino !== match.identity.ino ||
+		snapshot.stat.size !== match.identity.size ||
+		snapshot.stat.mtimeNs !== match.identity.mtimeNs ||
+		digest !== match.identity.sha256
+	)
+		return fail("invalid_input", "session.delete session changed after managed ownership was verified.");
 	return {
 		storage,
 		target: {
-			sessionsRoot: storageRoot,
-			transcriptPath: resolved,
+			sessionsRoot: inventory.scope.sessionsRoot,
+			transcriptPath: candidatePath,
 			sessionId: id,
 			cwd,
-			transcriptIdentity: { dev: snapshot.stat.dev, ino: snapshot.stat.ino },
+			transcriptIdentity: {
+				dev: snapshot.stat.dev,
+				ino: snapshot.stat.ino,
+				size: snapshot.stat.size,
+				mtimeNs: snapshot.stat.mtimeNs,
+				sha256: digest,
+			},
 		},
 		metadataRoot: requestedRoot,
 	};
@@ -1530,8 +2551,9 @@ async function executeLifecycleResponse(
 	operation: string,
 	input: Input,
 	identity: string,
+	cleanup?: CleanupEvidence,
 ): Promise<BrokerResponse> {
-	const requestedSessionId = sessionId(input);
+	const requestedSessionId = cleanup && operation === "session.delete" ? cleanup.sessionId : sessionId(input);
 	if (requestedSessionId !== undefined && !isCanonicalSessionId(requestedSessionId))
 		return fail("invalid_input", "sessionId must be a canonical safe identifier.");
 	const requestedSourceSessionId = text(input.sourceSessionId) ?? text(input.sourceId);
@@ -1785,7 +2807,7 @@ async function executeLifecycleResponse(
 		};
 	}
 
-	const id = sessionId(input);
+	const id = cleanup && operation === "session.delete" ? cleanup.sessionId : sessionId(input);
 	if (!id) return fail("invalid_input", "sessionId is required.");
 	if (!isCanonicalSessionId(id)) return fail("invalid_input", "sessionId must be a canonical safe identifier.");
 	await broker.index.refresh();
@@ -1914,12 +2936,102 @@ async function executeLifecycleResponse(
 		if (record?.terminalUncertain)
 			return fail("terminal_uncertain", "Session ownership is uncertain and cannot be deleted safely.");
 		if (record?.live) return fail("live_session", "Refusing to delete a live session; close it first.");
-		const validated = await validateDeletePath(broker, input, id, record);
+		const validated = await validateDeletePath(broker, input, id, record, cleanup);
 		if ("ok" in validated) return validated;
-		await broker.ledger.transition(identity, "effect_started", { intendedSessionId: id, effectMarker: randomUUID() });
-		let deleted: Awaited<ReturnType<FileSessionStorage["deleteSessionVerified"]>>;
+		const metadataPreflight = preflightLifecycleDeleteMetadata(validated.metadataRoot, id, record, value =>
+			processIncarnationForBroker(broker, value),
+		);
+		if ("ok" in metadataPreflight) return metadataPreflight;
+		const metadataCleanup = metadataPreflight.cleanup;
+		let cleanupTarget: VerifiedSessionDeleteTarget = {
+			...validated.target,
+			...(validated.target.plannedArtifactsPath &&
+			validated.target.detachedArtifactsPath !== validated.target.plannedArtifactsPath
+				? {}
+				: {
+						plannedArtifactsPath: path.join(
+							path.dirname(validated.target.transcriptPath),
+							`.gjc-delete-${randomUUID()}-artifacts`,
+						),
+					}),
+			...(validated.target.plannedTranscriptPath &&
+			validated.target.detachedTranscriptPath !== validated.target.plannedTranscriptPath
+				? {}
+				: {
+						plannedTranscriptPath: path.join(
+							path.dirname(validated.target.transcriptPath),
+							`.gjc-delete-${randomUUID()}-transcript`,
+						),
+					}),
+		};
+		if (!cleanupTarget.artifactsRemoved && !cleanupTarget.expectedArtifactsIdentity) {
+			const artifactsPath = cleanupTarget.transcriptPath.slice(0, -6);
+			try {
+				const stat = fsSync.lstatSync(artifactsPath, { bigint: true });
+				if (stat.isSymbolicLink() || !stat.isDirectory())
+					return fail("terminal_uncertain", "Artifact cleanup target is not an exact directory.");
+				validateManagedArtifactTree(artifactsPath);
+				const tree = native.snapshotDirectoryTree(artifactsPath);
+				if (!tree.ok || !tree.snapshot)
+					return fail(
+						"terminal_uncertain",
+						`Artifact tree authority could not be captured: ${tree.code ?? "unknown"}`,
+					);
+				cleanupTarget = {
+					...cleanupTarget,
+					expectedArtifactsIdentity: {
+						dev: stat.dev,
+						ino: stat.ino,
+						size: Number(stat.size),
+						mtimeNs: stat.mtimeNs,
+						sha256: "",
+					},
+					expectedArtifactsTree: tree.snapshot,
+				};
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			}
+		}
+		const preauthorizedCleanup: CleanupEvidence = {
+			phase: cleanupTarget.artifactsRemoved ? "transcript" : "artifacts",
+			sessionId: cleanupTarget.sessionId,
+			sessionsRoot: cleanupTarget.sessionsRoot,
+			transcriptPath: cleanupTarget.transcriptPath,
+			cwd: cleanupTarget.cwd,
+			...(cleanupTarget.artifactsRemoved ? { artifactsRemoved: true } : {}),
+			metadataRoot: validated.metadataRoot,
+			transcriptIdentity: serializeCleanupIdentity(cleanupTarget.transcriptIdentity),
+			...(cleanupTarget.expectedArtifactsIdentity
+				? { artifactsIdentity: serializeCleanupIdentity(cleanupTarget.expectedArtifactsIdentity) }
+				: {}),
+			...(cleanupTarget.expectedArtifactsIdentity && cleanupTarget.plannedArtifactsPath
+				? {
+						artifactTree: {
+							identity: serializeCleanupIdentity(cleanupTarget.expectedArtifactsIdentity),
+							snapshot: cleanupTarget.expectedArtifactsTree!,
+							plannedPath: cleanupTarget.plannedArtifactsPath,
+							...(cleanupTarget.detachedArtifactsPath
+								? { detachedPath: cleanupTarget.detachedArtifactsPath }
+								: {}),
+						},
+					}
+				: {}),
+
+			...(cleanupTarget.plannedArtifactsPath ? { plannedArtifactsPath: cleanupTarget.plannedArtifactsPath } : {}),
+			...(cleanupTarget.plannedTranscriptPath ? { plannedTranscriptPath: cleanupTarget.plannedTranscriptPath } : {}),
+		};
+		await broker.ledger.transition(identity, "effect_started", {
+			intendedSessionId: id,
+			effectMarker: randomUUID(),
+			response: fail(
+				"cleanup_pending",
+				"Saved session cleanup is preauthorized for durable reconciliation.",
+				preauthorizedCleanup,
+			),
+		});
+		let deleted: VerifiedSessionDeleteResult;
 		try {
-			deleted = await validated.storage.deleteSessionVerified(validated.target);
+			deleted = await validated.storage.deleteSessionVerified(cleanupTarget);
 		} catch (error) {
 			if (error instanceof SessionDeleteVerificationError)
 				return fail(
@@ -1931,27 +3043,95 @@ async function executeLifecycleResponse(
 				`Unable to delete saved session artifacts: ${error instanceof Error ? error.message : String(error)}`,
 			);
 		}
+		if (deleted.kind === "artifacts_removed") {
+			const transcriptPhaseCleanup = {
+				...preauthorizedCleanup,
+				phase: "transcript" as const,
+				artifactsRemoved: true,
+				...(preauthorizedCleanup.artifactTree
+					? { artifactTree: { ...preauthorizedCleanup.artifactTree, completed: true as const } }
+					: {}),
+			};
+
+			await broker.ledger.transition(identity, "effect_started", {
+				intendedSessionId: id,
+				response: fail(
+					"cleanup_pending",
+					"Saved session artifacts were removed; transcript cleanup is preauthorized.",
+					transcriptPhaseCleanup,
+				),
+			});
+			deleted = await validated.storage.deleteSessionVerified({
+				...cleanupTarget,
+				expectedArtifactsIdentity: undefined,
+				detachedArtifactsPath: undefined,
+				artifactsRemoved: true,
+			});
+		}
 		if (deleted.kind === "cleanup_pending")
 			return fail(
 				"cleanup_pending",
 				`Saved session cleanup is pending in ${deleted.phase}: ${deleted.error.message}`,
 				{
 					phase: deleted.phase,
-					transcriptIdentity: {
-						dev: deleted.transcriptIdentity.dev.toString(),
-						ino: deleted.transcriptIdentity.ino.toString(),
-					},
+					sessionId: validated.target.sessionId,
+					sessionsRoot: validated.target.sessionsRoot,
+					transcriptPath: validated.target.transcriptPath,
+					cwd: validated.target.cwd,
+					metadataRoot: validated.metadataRoot,
+					transcriptIdentity: serializeCleanupIdentity(deleted.transcriptIdentity),
 					...(deleted.phase === "artifacts" && deleted.artifactsIdentity
+						? { artifactsIdentity: serializeCleanupIdentity(deleted.artifactsIdentity) }
+						: {}),
+					...(deleted.phase === "artifacts" && deleted.artifactsIdentity && cleanupTarget.plannedArtifactsPath
 						? {
-								artifactsIdentity: {
-									dev: deleted.artifactsIdentity.dev.toString(),
-									ino: deleted.artifactsIdentity.ino.toString(),
+								artifactTree: {
+									identity: serializeCleanupIdentity(deleted.artifactsIdentity),
+									snapshot: deleted.artifactsTree,
+									plannedPath: cleanupTarget.plannedArtifactsPath,
+									...(deleted.detachedArtifactsPath ? { detachedPath: deleted.detachedArtifactsPath } : {}),
 								},
 							}
 						: {}),
+					...(deleted.phase === "artifacts" ? { detachedArtifactsPath: deleted.detachedArtifactsPath } : {}),
+					...(deleted.phase === "transcript" && deleted.detachedTranscriptPath
+						? { detachedTranscriptPath: deleted.detachedTranscriptPath }
+						: {}),
+					...(deleted.phase === "transcript" ? { artifactsRemoved: true } : {}),
+					...(deleted.phase === "transcript" &&
+					cleanupTarget.plannedArtifactsPath &&
+					cleanupTarget.expectedArtifactsIdentity
+						? {
+								artifactTree: {
+									identity: serializeCleanupIdentity(cleanupTarget.expectedArtifactsIdentity),
+									snapshot: cleanupTarget.expectedArtifactsTree!,
+									plannedPath: cleanupTarget.plannedArtifactsPath,
+									completed: true as const,
+								},
+							}
+						: {}),
+					...(cleanupTarget.plannedArtifactsPath
+						? { plannedArtifactsPath: cleanupTarget.plannedArtifactsPath }
+						: {}),
+					...(cleanupTarget.plannedTranscriptPath
+						? { plannedTranscriptPath: cleanupTarget.plannedTranscriptPath }
+						: {}),
 				},
 			);
 
+		const completion = { ok: true, result: { sessionId: id } } as const;
+		if (metadataCleanup.lifecycleFiles?.length) {
+			await broker.ledger.transition(identity, "effect_started", {
+				intendedSessionId: id,
+				response: fail(
+					"cleanup_pending",
+					"Lifecycle metadata cleanup is preauthorized for durable reconciliation.",
+					metadataCleanup,
+				),
+			});
+			const reconciled = await reconcileLifecycleCleanup(broker, identity, metadataCleanup, completion);
+			if (!reconciled.ok) return reconciled;
+		}
 		if (record)
 			await broker.index.append({
 				type: "session_closed",
@@ -1960,18 +3140,7 @@ async function executeLifecycleResponse(
 				endpointGeneration: record.endpointGeneration,
 				pid: record.pid,
 			});
-		try {
-			await fs.rm(lifecycleMarkerPath(validated.metadataRoot, id), { force: true });
-		} catch (error) {
-			return fail(
-				"cleanup_pending",
-				`Saved session was deleted but lifecycle metadata cleanup is pending: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-				{ phase: "metadata" },
-			);
-		}
-		return { ok: true, result: { sessionId: id } };
+		return completion;
 	}
 	return fail("invalid_input", "Unknown lifecycle operation.");
 }
@@ -2036,6 +3205,35 @@ async function exactCleanupProof(
 		: undefined;
 }
 
+function validateLifecycleDeleteMetadataBinding(
+	broker: Broker,
+	operation: string,
+	input: Input,
+	identity: string,
+	cleanup: CleanupEvidence,
+): BrokerResponse | undefined {
+	if (operation !== "session.delete")
+		return fail("terminal_uncertain", "Lifecycle delete metadata cleanup is not authorized for this operation.");
+	const requestedId = sessionId(input);
+	const cwd = lifecycleCwd(input);
+	const requestedRoot = stateRoot(input, cwd);
+	if (
+		!requestedId ||
+		!isCanonicalSessionId(requestedId) ||
+		!cwd ||
+		!requestedRoot ||
+		!hasDefaultStateRoot(cwd, requestedRoot) ||
+		cleanup.sessionId !== requestedId ||
+		!cleanup.metadataRoot ||
+		path.resolve(cleanup.metadataRoot) !== requestedRoot
+	)
+		return fail("terminal_uncertain", "Lifecycle delete metadata cleanup does not match the normalized request.");
+	const recordedRoot = broker.ledger.get(identity)?.effectIntent?.stateRoot;
+	if (recordedRoot && path.resolve(recordedRoot) !== requestedRoot)
+		return fail("terminal_uncertain", "Lifecycle delete metadata cleanup does not match the recorded workspace.");
+	return undefined;
+}
+
 export interface LifecycleExecutionOutcome {
 	response: BrokerResponse;
 	durableEffects?: LifecycleDurableEffectsReceipt;
@@ -2049,8 +3247,59 @@ export async function executeLifecycle(
 	operation: string,
 	input: Input,
 	identity: string,
+	cleanup?: CleanupEvidence,
 ): Promise<LifecycleExecutionOutcome> {
-	const response = await executeLifecycleResponse(broker, operation, input, identity);
+	if (cleanup?.phase === "metadata") {
+		if (operation !== "session.delete")
+			return {
+				response: fail(
+					"terminal_uncertain",
+					"Legacy metadata cleanup is not authorized for this lifecycle operation.",
+				),
+			};
+		const migrated = legacyMetadataCleanupPlan(cleanup);
+		if (!migrated)
+			return {
+				response: fail(
+					"terminal_uncertain",
+					"Legacy metadata cleanup replay lacks immutable identity-bound intent.",
+				),
+			};
+		const binding = validateLifecycleDeleteMetadataBinding(broker, operation, input, identity, migrated);
+		if (binding) return { response: binding };
+		await broker.ledger.transition(identity, "effect_started", {
+			response: fail(
+				"cleanup_pending",
+				"Legacy lifecycle metadata cleanup is preauthorized for durable reconciliation.",
+				migrated,
+			),
+		});
+		return {
+			response: await reconcileLifecycleCleanup(broker, identity, migrated, {
+				ok: true,
+				result: { sessionId: migrated.sessionId },
+			}),
+		};
+	}
+	if (cleanup?.phase === "lifecycle") {
+		const shapeValidation = validateLifecycleCleanupShape(cleanup);
+		if (shapeValidation) return { response: shapeValidation };
+		if (cleanup.lifecycleDeleteMetadata === true || operation === "session.delete") {
+			const binding = validateLifecycleDeleteMetadataBinding(broker, operation, input, identity, cleanup);
+			if (binding) return { response: binding };
+		}
+		return {
+			response: await reconcileLifecycleCleanup(
+				broker,
+				identity,
+				cleanup,
+				operation === "session.delete"
+					? { ok: true, result: { sessionId: cleanup.sessionId } }
+					: fail("spawn_failed", "No ready SDK endpoint remains available."),
+			),
+		};
+	}
+	const response = await executeLifecycleResponse(broker, operation, input, identity, cleanup);
 	const entry = broker.ledger.get(identity);
 	const priorDurableEffects = entry?.durableEffects;
 	const evidenceCwd = entry?.effectIntent?.worktree?.worktreePath ?? lifecycleCwd(input);
@@ -2105,6 +3354,30 @@ export async function executeLifecycle(
 					digest: createHash("sha256").update(canonicalJson(durableEffectsBody)).digest("hex"),
 				}
 			: undefined;
+	const lifecycleCleanupResponse =
+		evidence && root && entry?.intendedSessionId && expected && cleanupProof
+			? await (async () => {
+					const cleanupIntent = lifecycleCleanupPlan(root, entry.intendedSessionId!, expected, evidence);
+					await broker.ledger.transition(identity, "effect_started", {
+						response: fail(
+							"cleanup_pending",
+							"Lifecycle failure cleanup is preauthorized for durable reconciliation.",
+							cleanupIntent,
+						),
+					});
+					return reconcileLifecycleCleanup(broker, identity, cleanupIntent);
+				})()
+			: undefined;
+	if (
+		lifecycleCleanupResponse &&
+		!lifecycleCleanupResponse.ok &&
+		lifecycleCleanupResponse.error.code !== "spawn_failed"
+	)
+		return {
+			response: lifecycleCleanupResponse,
+			...(durableEffects ? { durableEffects } : {}),
+			...(startupFailure ? { startupFailure } : {}),
+		};
 	const terminalResponse: BrokerResponse =
 		!response.ok &&
 		entry?.effectMarker &&
@@ -2137,21 +3410,5 @@ export async function executeLifecycle(
 		response: terminalResponse,
 		...(durableEffects ? { durableEffects } : {}),
 		...(startupFailure ? { startupFailure } : {}),
-		...(evidence && root && entry?.intendedSessionId && cleanupProof
-			? {
-					deferredArtifactCleanup: async () => {
-						const current = await readLifecycleFailureArtifact(
-							lifecycleFailurePath(root, entry.intendedSessionId!, evidence.artifact.effectMarker),
-							evidence.artifact,
-						);
-						const marker = await readEffectMarker(lifecycleMarkerPath(root, entry.intendedSessionId!));
-						if (current?.digest !== evidence.digest || !marker || !sameEffectMarker(marker, evidence.artifact))
-							return;
-						await fs.rm(lifecycleFailurePath(root, entry.intendedSessionId!, evidence.artifact.effectMarker));
-						await fs.rm(lifecycleMarkerPath(root, entry.intendedSessionId!));
-						await syncDirectory(path.join(root, "sdk"));
-					},
-				}
-			: {}),
 	};
 }