@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/sdk/host/session-runtime.ts

@@ -37,8 +37,15 @@ import {
 	settleOwnedWork,
 } from "../../session/terminal-abort";
 import { parseThinkingLevel } from "../../thinking";
+import { readEndpointFile } from "../broker/endpoint-authority";
 import { ensureBroker } from "../broker/ensure";
-import { SessionIndex } from "../broker/session-index";
+import { processIncarnation } from "../broker/process-incarnation";
+import {
+	type MasterRoleAttestationV2,
+	resolveSessionLocator,
+	SessionIndex,
+	type SessionLocatorV2,
+} from "../broker/session-index";
 import {
 	parseSyntheticModelId,
 	resolveSyntheticModelSelection,
@@ -49,17 +56,28 @@ import {
 import { projectQ10Models } from "../models.js";
 import { PromptDeadlineManager, type PromptTerminalTransitionEvidence } from "../prompt-deadline-manager";
 import { formatPromptFailureForLocalLog, sanitizePromptFailure } from "../prompt-failure";
+import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import { validateRequiredPromptText } from "../protocol/adapter-validation";
 import { OPERATIONS } from "../protocol/operation-registry";
+import { type ReceiptState, reduceReceiptState } from "../receipt-state";
 import {
 	createKindAwareReconciliation,
 	createReconciliationStore,
 	type KindAwareReconciliation,
 	resolveReconciliationSessionFile,
 } from "../reconciliation-extensions";
-import { sanitizeTurnResultContent, type TurnResultContent } from "../turn-result";
-import { type ControlSurface, controlRequestFromFrame, dispatchControl } from "./control";
-import { BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD } from "./control/runtime-gate";
+import {
+	reduceTurnResultContent,
+	reportableTurnResultContent,
+	sanitizeTurnResultContent,
+	type TurnResultContent,
+} from "../turn-result";
+import { type ControlSurface, controlRequestFromFrame, dispatchControl, terminalAbortIdentity } from "./control";
+import {
+	BROKER_RUNTIME_ABORT_CAPABILITY_FIELD,
+	BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD,
+	hasBrokerRuntimeAbortCapability,
+} from "./control/runtime-gate";
 import { SessionSdkHost, type SessionSdkHostOptions } from "./host";
 import { clearAutoroutingInactive, isAutoroutingInactive, markAutoroutingInactive } from "./internal-autorouting-state";
 import { CursorRegistry, QueryHandlers, RevisionStore, type SessionSurface } from "./query";
@@ -103,6 +121,65 @@ const SDK_ONLY_TERMINAL_PUBLICATION_WAIT_MS = 1_000;
  *  after this bound are abandoned — their durable broker state is the recovery
  *  authority, and outcomes are inherently uncertain. */
 const GATE_RESOLUTION_QUIESCENCE_MS = 5_000;
+/** Master verification fields are ephemeral protocol values, not unbounded input. */
+const MASTER_AUTH_VALUE_MAX_LENGTH = 512;
+const MASTER_AUTH_VALUE_PATTERN = /^[A-Za-z0-9_-]+$/u;
+/** Keep replay protection finite even when an authenticated client floods nonces. */
+const MASTER_NONCE_REPLAY_MAX_ENTRIES = 1_024;
+/** Verification exchanges complete in seconds; retain replay evidence for a bounded window. */
+const MASTER_NONCE_REPLAY_TTL_MS = 5 * 60_000;
+
+export type MasterCapabilityReplayState = Map<string, number>;
+
+export function verifyMasterCapabilityFrame(input: {
+	frame: { nonce: unknown; attestationEpoch: unknown; capability: unknown };
+	expectedCapability: string | undefined;
+	expectedEpoch: string | undefined;
+	replay: MasterCapabilityReplayState;
+	now?: number;
+}): { ok: boolean; nonce: string; attestationEpoch: string } {
+	const now = input.now ?? Date.now();
+	for (const [consumedNonce, expiresAt] of input.replay) {
+		if (expiresAt <= now) input.replay.delete(consumedNonce);
+	}
+	const bounded = (value: unknown): value is string =>
+		typeof value === "string" &&
+		value.length > 0 &&
+		value.length <= MASTER_AUTH_VALUE_MAX_LENGTH &&
+		MASTER_AUTH_VALUE_PATTERN.test(value);
+	const nonce = bounded(input.frame.nonce) ? input.frame.nonce : "";
+	const epoch = bounded(input.frame.attestationEpoch) ? input.frame.attestationEpoch : "";
+	const capability = bounded(input.frame.capability) ? input.frame.capability : "";
+	const expectedCapability = bounded(input.expectedCapability) ? input.expectedCapability : "";
+	const expectedEpoch = bounded(input.expectedEpoch) ? input.expectedEpoch : "";
+	const authenticatedFields =
+		bounded(input.frame.nonce) &&
+		bounded(input.frame.attestationEpoch) &&
+		bounded(input.frame.capability) &&
+		bounded(input.expectedCapability) &&
+		bounded(input.expectedEpoch) &&
+		epoch === expectedEpoch;
+	const expectedBytes = Buffer.from(expectedCapability);
+	const capabilityBytes = Buffer.from(capability);
+	const capabilityMatches =
+		authenticatedFields &&
+		expectedBytes.length === capabilityBytes.length &&
+		crypto.timingSafeEqual(expectedBytes, capabilityBytes);
+	const reusable = capabilityMatches && !input.replay.has(nonce);
+	if (reusable) {
+		if (input.replay.size >= MASTER_NONCE_REPLAY_MAX_ENTRIES) {
+			const oldest = input.replay.keys().next().value;
+			if (typeof oldest === "string") input.replay.delete(oldest);
+		}
+		input.replay.set(nonce, now + MASTER_NONCE_REPLAY_TTL_MS);
+	}
+	return {
+		ok: reusable,
+		nonce,
+		attestationEpoch: authenticatedFields ? epoch : "",
+	};
+}
+
 /** Maximum time a replaced runtime may retain a lifecycle persistence task. */
 const LIFECYCLE_QUIESCENCE_MS = 1_000;
 
@@ -142,6 +219,8 @@ export interface SessionSdkRuntimeOptions
 	settings?: Settings;
 	/** Mutable shadow of patched config values merged into query readback. */
 	configOverrides?: Map<string, unknown>;
+	/** Stable master lineage identity retained across session switches/branches. */
+	masterOwnerSessionId?: string;
 }
 
 export interface SdkOnlyInvocationRecord extends InvocationCorrelation {
@@ -152,6 +231,8 @@ export interface SdkOnlyInvocationRecord extends InvocationCorrelation {
 	startedAt?: number;
 	terminalAt?: number;
 	error?: { code: string; message: string };
+	content?: TurnResultContent;
+	receiptState?: Exclude<ReceiptState, "absent">;
 	outcome?: unknown;
 	pendingOutcome?: unknown;
 	skillName?: string;
@@ -400,6 +481,8 @@ export interface CreateSdkSessionRuntimeOptions {
 	agentDir: string;
 	/** Lifecycle-owned sessions require broker publication before they become usable. */
 	brokerRegistrationRequired?: boolean;
+	/** Trusted broker-issued lifecycle marker bound to lifecycle host index events. */
+	lifecycleRequestId?: string;
 	createTransport(input: {
 		sessionId: string;
 		stateRoot: string;
@@ -411,6 +494,12 @@ export interface CreateSdkSessionRuntimeOptions {
 	onSdkRequest?: SessionSdkHostOptions["onRequest"];
 	/** Mutable shadow of patched config values merged into query readback. */
 	configOverrides?: Map<string, unknown>;
+	/** In-memory master capability for private broker verification only. */
+	masterCapability?: string;
+	/** Opaque direct-role epoch this effective host may adopt. */
+	masterAttestationEpoch?: string;
+	/** Stable master lineage identity retained across session switches/branches. */
+	masterOwnerSessionId?: string;
 	/** Private session-owned terminal-abort capabilities; never exposed on ExtensionContext. */
 	terminalAbortSeams?: SdkOnlyTerminalAbortSeams;
 	/** Callback when a frame is admitted to the runtime (test harness). */
@@ -419,6 +508,8 @@ export interface CreateSdkSessionRuntimeOptions {
 	onLifecycleDrainTimeoutForTests?: () => void;
 	/** Test-only observation of bounded failure-diagnostic deduplication state. */
 	onFailureDiagnosticKeyCountForTests?: (count: number) => void;
+	/** Test-only observation after a resolved invocation completion is reconciled. */
+	onInvocationCompletionReconciledForTests?: (kind: InvocationKind, correlation: InvocationCorrelation) => void;
 }
 
 function unavailable(operation: string): () => never {
@@ -436,7 +527,67 @@ export interface InvocationCorrelation {
 
 export type InvocationKind = "prompt" | "skill" | "steer";
 type InvocationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed" | "uncertain";
+type InvocationOutcome = SdkPromptTerminalOutcome;
+type InvocationOutcomeInput = {
+	kind: string;
+	reason?: unknown;
+	code?: unknown;
+	message?: unknown;
+	provenance?: unknown;
+};
 const EMPTY_PROMPT_FAILURE = { code: "prompt_failed", message: "Prompt submission failed." } as const;
+const PRESERVED_PROVIDER_FAILURE_CODES = new Set([
+	"provider_down",
+	"provider_unavailable",
+	"provider_rejected",
+	"upstream_stream_interrupted",
+	"argument_validation",
+	"execution",
+	"upstream_error",
+	"transport_reset",
+]);
+const isPreservedProviderFailure = (code: string | undefined): boolean =>
+	code !== undefined && (PRESERVED_PROVIDER_FAILURE_CODES.has(code) || code.startsWith("provider_http_"));
+
+/**
+ * Durable reconciliation accepts only the bounded outcome vocabulary from
+ * reconciliation-store.ts. Provider diagnostics keep their specific safe code
+ * in `error`, while the durable outcome is normalized to the public failure
+ * classifier so a failed terminal can never be quarantined on reload.
+ */
+function canonicalFailedOutcome(
+	failure?: { code?: unknown; message?: unknown },
+	provenance: "agent_failed" | "deadline" = "agent_failed",
+): InvocationOutcome {
+	const deadline = provenance === "deadline" || failure?.code === "prompt_deadline_exceeded";
+	return {
+		kind: "failed",
+		code: deadline ? "prompt_deadline_exceeded" : "prompt_failed",
+		message: deadline ? "Prompt deadline exceeded." : EMPTY_PROMPT_FAILURE.message,
+		provenance: deadline ? "deadline" : "agent_failed",
+	};
+}
+
+function canonicalTerminalOutcome(
+	outcome: unknown,
+	failure?: { code?: unknown; message?: unknown },
+): InvocationOutcome | undefined {
+	if (outcome && typeof outcome === "object") {
+		const candidate = outcome as { kind?: unknown; reason?: unknown; provenance?: unknown; code?: unknown };
+		if (candidate.kind === "stopped") {
+			if (candidate.reason === "cancelled" && candidate.provenance === "client_cancel")
+				return { kind: "stopped", reason: "cancelled", provenance: "client_cancel" };
+			return undefined;
+		}
+		if (candidate.kind === "failed")
+			return canonicalFailedOutcome(
+				{ code: candidate.code, message: (outcome as { message?: unknown }).message },
+				candidate.provenance === "deadline" ? "deadline" : "agent_failed",
+			);
+	}
+	if (failure !== undefined) return canonicalFailedOutcome(failure);
+	return undefined;
+}
 interface InvocationRecord extends InvocationCorrelation {
 	kind: InvocationKind;
 	revision: number;
@@ -447,6 +598,9 @@ interface InvocationRecord extends InvocationCorrelation {
 	startedAt?: number;
 	terminalAt?: number;
 	error?: { code: string; message: string };
+	content?: TurnResultContent;
+	receiptState?: Exclude<ReceiptState, "absent">;
+	outcome?: unknown;
 }
 export interface InvocationReconciliation {
 	/** Shared v2 reconciliation owner; present for durable terminal admission. */
@@ -462,7 +616,7 @@ export interface InvocationReconciliation {
 					type: "agent_start" | "agent_end";
 					content?: TurnResultContent;
 					hasActivity?: boolean;
-					outcome?: { kind: "stopped"; reason: "cancelled"; provenance: "client_cancel" };
+					outcome?: InvocationOutcome;
 			  }
 			| { type: "agent_failed"; error: unknown; content?: TurnResultContent; hasActivity?: boolean },
 	): Promise<void>;
@@ -477,8 +631,8 @@ export interface InvocationReconciliation {
 	claimPendingOutcome(
 		kind: InvocationKind,
 		correlation: InvocationCorrelation,
-		outcome: { kind: string; code: string; message: string; provenance?: string },
-	): Promise<unknown>;
+		outcome: InvocationOutcomeInput,
+	): Promise<InvocationOutcome>;
 	// Positional compatibility (exact-head review P1): the 4th argument is either
 	// the generation-fence isCurrent callback or the legacy recordError object;
 	// both shapes are normalized in the implementation so a legacy object can
@@ -486,7 +640,7 @@ export interface InvocationReconciliation {
 	finalizeOutcome(
 		kind: InvocationKind,
 		correlation: InvocationCorrelation,
-		outcome?: { kind: string; code: string; message: string; provenance?: string },
+		outcome?: InvocationOutcomeInput,
 		arg4?: (() => boolean) | { code: string; message: string },
 		// Terminal evidence accepted by finalizeOutcome (exact-head review P1/P2):
 		// when an explicit outcome is absent, a content-bearing, activity-bearing,
@@ -729,25 +883,71 @@ export function createInvocationReconciliation(
 						// so a real lifecycle event is never swallowed.
 					}
 					const current = records.get(recordKey);
+					const incomingOutcome = frame.type === "agent_end" ? canonicalTerminalOutcome(frame.outcome) : undefined;
+					const providerFailure =
+						current?.error !== undefined && current.error.code !== "prompt_deadline_exceeded";
+					if (
+						current !== undefined &&
+						frame.type === "agent_end" &&
+						incomingOutcome?.kind === "failed" &&
+						incomingOutcome.provenance !== "deadline"
+					) {
+						const content = reduceTurnResultContent(current.content, frame.content);
+						const failed = {
+							...current,
+							revision: ++mutationRevision,
+							status: "failed" as const,
+							outcome: incomingOutcome,
+							error:
+								current.error?.code !== "prompt_deadline_exceeded" && current.error !== undefined
+									? current.error
+									: { code: incomingOutcome.code, message: incomingOutcome.message },
+							content,
+							receiptState: reduceReceiptState(
+								current.receiptState,
+								reportableTurnResultContent(content) ? "present" : undefined,
+							),
+						};
+						delete (failed as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+						delete (failed as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
+						records.set(recordKey, failed);
+						try {
+							await persist();
+						} catch (error) {
+							if (records.get(recordKey) === failed) records.set(recordKey, current);
+							throw error;
+						}
+						return;
+					}
 					if (
 						frame.type === "agent_end" &&
 						current === pending.finalizedRecord &&
+						incomingOutcome?.kind !== "failed" &&
+						!providerFailure &&
 						(kind !== "prompt" ||
-							frame.outcome?.kind === "stopped" ||
+							incomingOutcome?.kind === "stopped" ||
 							frame.hasActivity === true ||
 							frame.content?.text.trim())
 					) {
 						// A real lifecycle end that arrived during deadline finalization is
 						// stronger evidence than the synthetic deadline outcome. Upgrade the
-						// durable terminal instead of treating the event as a duplicate.
+						// durable terminal instead of treating it as a duplicate.
+						const content = reduceTurnResultContent(current.content, frame.content);
 						const upgraded = {
 							...current,
 							revision: ++mutationRevision,
 							status: "terminal_ok" as const,
+							content,
+							...(incomingOutcome?.kind === "stopped" ? { outcome: incomingOutcome } : {}),
+							receiptState: reduceReceiptState(
+								current.receiptState,
+								reportableTurnResultContent(content) ? "present" : undefined,
+							),
 						};
 						// Drop the superseded synthetic deadline error so the surfaced payload is
 						// not the contradictory {status: terminal_ok, error: prompt_deadline_exceeded}.
 						delete (upgraded as Partial<InvocationRecord>).error;
+						if (incomingOutcome?.kind !== "stopped") delete (upgraded as Partial<InvocationRecord>).outcome;
 						records.set(recordKey, upgraded);
 						try {
 							await persist();
@@ -771,18 +971,115 @@ export function createInvocationReconciliation(
 				}
 			}
 			if (record.terminalAt !== undefined) {
+				if (frame.type === "agent_end") {
+					const incomingOutcome = canonicalTerminalOutcome(frame.outcome);
+					if (incomingOutcome?.kind === "failed" && incomingOutcome.provenance !== "deadline") {
+						const content = reduceTurnResultContent(record.content, frame.content);
+						const failed = {
+							...record,
+							revision: ++mutationRevision,
+							status: "failed" as const,
+							outcome: incomingOutcome,
+							error:
+								record.error?.code !== "prompt_deadline_exceeded" && record.error !== undefined
+									? record.error
+									: { code: incomingOutcome.code, message: incomingOutcome.message },
+							content,
+							receiptState: reduceReceiptState(
+								record.receiptState,
+								reportableTurnResultContent(content) ? "present" : undefined,
+							),
+						};
+						delete (failed as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+						delete (failed as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
+						records.set(recordKey, failed);
+						try {
+							await persist();
+						} catch (error) {
+							if (records.get(recordKey) === failed) records.set(recordKey, record);
+							throw error;
+						}
+						return;
+					}
+				}
+				if (frame.type === "agent_failed" && record.error?.code === "prompt_deadline_exceeded") {
+					const failure = sanitizePromptFailure(frame.error);
+					const next = {
+						...record,
+						revision: ++mutationRevision,
+						status: "failed" as const,
+						error: failure,
+						outcome: canonicalFailedOutcome(failure),
+					};
+					delete (next as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+					delete (next as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
+					records.set(recordKey, next);
+					try {
+						await persist();
+					} catch (error) {
+						if (records.get(recordKey) === next) records.set(recordKey, record);
+						throw error;
+					}
+					return;
+				}
+				if (frame.type === "agent_end" && record.error?.code !== "prompt_deadline_exceeded") {
+					const content = reduceTurnResultContent(record.content, frame.content);
+					const receiptState = reduceReceiptState(
+						record.receiptState,
+						reportableTurnResultContent(content) ? "present" : undefined,
+					);
+					let outcome = record.outcome;
+					const incomingOutcome = canonicalTerminalOutcome(frame.outcome);
+					if (outcome === undefined) {
+						if (record.status === "failed" && record.error !== undefined)
+							outcome = canonicalFailedOutcome(record.error);
+						else if (record.status === "terminal_ok" && incomingOutcome?.kind === "stopped")
+							outcome = incomingOutcome;
+					}
+					if (content !== record.content || receiptState !== record.receiptState || outcome !== record.outcome) {
+						const enriched = {
+							...record,
+							revision: ++mutationRevision,
+							content,
+							receiptState,
+							...(outcome === undefined ? {} : { outcome }),
+						};
+						records.set(recordKey, enriched);
+						try {
+							await persist();
+						} catch (error) {
+							if (records.get(recordKey) === enriched) records.set(recordKey, record);
+							throw error;
+						}
+					}
+					return;
+				}
 				if (
 					frame.type === "agent_end" &&
 					record.error?.code === "prompt_deadline_exceeded" &&
+					canonicalTerminalOutcome(frame.outcome)?.kind !== "failed" &&
 					(kind !== "prompt" ||
-						frame.outcome?.kind === "stopped" ||
+						canonicalTerminalOutcome(frame.outcome)?.kind === "stopped" ||
 						frame.hasActivity === true ||
 						frame.content?.text.trim())
 				) {
-					const upgraded = { ...record, revision: ++mutationRevision, status: "terminal_ok" as const };
+					const content = reduceTurnResultContent(record.content, frame.content);
+					const incomingOutcome = canonicalTerminalOutcome(frame.outcome);
+					const upgraded = {
+						...record,
+						revision: ++mutationRevision,
+						status: "terminal_ok" as const,
+						content,
+						...(incomingOutcome?.kind === "stopped" ? { outcome: incomingOutcome } : {}),
+						receiptState: reduceReceiptState(
+							record.receiptState,
+							reportableTurnResultContent(content) ? "present" : undefined,
+						),
+					};
 					// The synthetic deadline error is superseded evidence; terminal_ok must not
 					// surface a deadline failure for a prompt that actually completed.
 					delete (upgraded as Partial<InvocationRecord>).error;
+					if (incomingOutcome?.kind !== "stopped") delete (upgraded as Partial<InvocationRecord>).outcome;
 					records.set(recordKey, upgraded);
 					try {
 						await persist();
@@ -839,19 +1136,43 @@ export function createInvocationReconciliation(
 				if (next.error === undefined || (next.error.code === "agent_failed" && failure.code !== "agent_failed"))
 					next.error = failure;
 			} else {
+				const pendingOutcome = (next as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+				delete (next as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+				delete (next as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
+				next.content = reduceTurnResultContent(next.content, frame.content);
+				const incomingOutcome = canonicalTerminalOutcome(frame.outcome) ?? canonicalTerminalOutcome(pendingOutcome);
 				if (
+					incomingOutcome?.kind === "stopped" &&
+					(next.error === undefined || next.error.code === "prompt_deadline_exceeded")
+				) {
+					next.outcome = incomingOutcome;
+					if (next.error?.code === "prompt_deadline_exceeded") delete next.error;
+					next.status = "terminal_ok";
+				} else if (incomingOutcome?.kind === "failed") {
+					next.outcome = incomingOutcome;
+					if (next.error === undefined)
+						next.error = { code: incomingOutcome.code, message: incomingOutcome.message };
+					next.status = "failed";
+				} else if (next.error !== undefined) {
+					next.outcome = canonicalFailedOutcome(next.error);
+					next.status = "failed";
+				} else if (
 					kind === "prompt" &&
-					next.error === undefined &&
 					frame.type === "agent_end" &&
-					frame.outcome?.kind !== "stopped" &&
 					!frame.content?.text.trim() &&
 					!frame.hasActivity
 				) {
 					next.status = "failed";
 					next.error = EMPTY_PROMPT_FAILURE;
-				} else next.status = next.error === undefined ? "terminal_ok" : "failed";
+					next.outcome = canonicalFailedOutcome(EMPTY_PROMPT_FAILURE);
+				} else next.status = "terminal_ok";
+				next.receiptState = reduceReceiptState(
+					next.receiptState,
+					reportableTurnResultContent(next.content) ? "present" : "missing",
+				);
 				next.terminalAt = Date.now();
 			}
+
 			records.set(recordKey, next);
 			try {
 				await persist();
@@ -862,20 +1183,24 @@ export function createInvocationReconciliation(
 		},
 		lookup(kind, selector) {
 			const record = find(kind, selector);
-			if (!record) return { status: "unknown" };
+			if (!record) return { status: "unknown", receiptState: "unknown" };
 			const identity = {
 				commandId: record.commandId,
 				turnId: record.turnId,
 				...(record.clientRef === undefined ? {} : { clientRef: record.clientRef }),
 				acceptedAt: record.acceptedAt,
 			};
-			if (record.status === "accepted") return { status: "accepted", ...identity };
-			if (record.status === "in_flight") return { status: "in_flight", ...identity, startedAt: record.startedAt };
+			if (record.status === "accepted") return { status: "accepted", receiptState: "absent", ...identity };
+			if (record.status === "in_flight")
+				return { status: "in_flight", receiptState: "absent", ...identity, startedAt: record.startedAt };
 			return {
 				status: record.status,
 				...identity,
 				...(record.startedAt === undefined ? {} : { startedAt: record.startedAt }),
 				terminalAt: record.terminalAt,
+				receiptState: record.receiptState ?? "unknown",
+				...(record.outcome === undefined ? {} : { outcome: record.outcome }),
+				...(reportableTurnResultContent(record.content) ? { content: record.content } : {}),
 				...(record.error === undefined ? {} : { error: record.error }),
 			};
 		},
@@ -902,11 +1227,13 @@ export function createInvocationReconciliation(
 		hydrate,
 		async claimPendingOutcome(kind, correlation, outcome) {
 			const record = records.get(key(kind, correlation));
-			if (!record || record.terminalAt !== undefined || record.kind !== kind) return outcome;
+			const normalized = canonicalTerminalOutcome(outcome);
+			if (normalized === undefined) throw new Error("Invalid terminal outcome.");
+			if (!record || record.terminalAt !== undefined || record.kind !== kind) return normalized;
 			const pending = (record as unknown as { pendingOutcome?: unknown }).pendingOutcome;
-			if (pending !== undefined) return pending;
+			if (pending !== undefined) return canonicalTerminalOutcome(pending) ?? normalized;
 			const next = { ...record, revision: ++mutationRevision } as InvocationRecord & { pendingOutcome?: unknown };
-			next.pendingOutcome = outcome;
+			next.pendingOutcome = normalized;
 			records.set(key(kind, correlation), next);
 			try {
 				await persist();
@@ -914,7 +1241,7 @@ export function createInvocationReconciliation(
 				if (records.get(key(kind, correlation)) === next) records.set(key(kind, correlation), record);
 				throw error;
 			}
-			return outcome;
+			return normalized;
 		},
 		async finalizeOutcome(
 			kind,
@@ -946,36 +1273,64 @@ export function createInvocationReconciliation(
 			const recordKey = key(kind, correlation);
 			const record = records.get(recordKey);
 			if (!record || record.terminalAt !== undefined || record.kind !== kind) return;
-			const finalOutcome = (outcome ??
-				(record as unknown as { pendingOutcome?: { kind: string; code: string; message: string } })
-					.pendingOutcome) as { kind: string; code: string; message: string } | undefined;
+			const requestedOutcome = canonicalTerminalOutcome(
+				outcome ?? (record as unknown as { pendingOutcome?: unknown }).pendingOutcome,
+			);
+			const priorFailure = record.error;
+			// A provider diagnostic recorded before a deadline finalization is stronger
+			// than the synthetic deadline claim. Preserve it as the terminal failure
+			// intent instead of allowing a later agent_end to look successful.
+			const finalOutcome =
+				priorFailure !== undefined && priorFailure.code !== "prompt_deadline_exceeded"
+					? canonicalFailedOutcome(priorFailure)
+					: requestedOutcome?.kind === "stopped"
+						? requestedOutcome
+						: priorFailure !== undefined &&
+								(requestedOutcome === undefined ||
+									(requestedOutcome.kind === "failed" &&
+										(requestedOutcome.code === "prompt_deadline_exceeded" ||
+											priorFailure.code !== "prompt_deadline_exceeded")))
+							? canonicalFailedOutcome(priorFailure)
+							: requestedOutcome;
 			const previousRecord = { ...record };
 			const finalizedRecord: InvocationRecord = { ...record, revision: ++mutationRevision, terminalAt: Date.now() };
-			if (finalOutcome?.kind === "failed") {
+			finalizedRecord.content = reduceTurnResultContent(finalizedRecord.content, evidence?.content);
+			let resolvedOutcome = finalOutcome;
+			if (resolvedOutcome?.kind === "stopped") {
+				// Stopped is a successful terminal boundary: it must never coexist with
+				// an earlier diagnostic failure.
+				finalizedRecord.status = "terminal_ok";
+				delete finalizedRecord.error;
+			} else if (resolvedOutcome?.kind === "failed") {
 				finalizedRecord.status = "failed";
-				// Legacy positional recordError overrides the recorded cause; the
-				// outcome's own code/message is the default (exact-head review P1).
 				finalizedRecord.error =
 					recordError !== undefined
 						? { code: recordError.code, message: recordError.message }
-						: { code: finalOutcome.code, message: finalOutcome.message };
-			} else if (kind === "prompt" && finalOutcome === undefined) {
+						: priorFailure !== undefined &&
+								(resolvedOutcome.code === "prompt_deadline_exceeded" ||
+									priorFailure.code !== "prompt_deadline_exceeded")
+							? priorFailure
+							: { code: resolvedOutcome.code, message: resolvedOutcome.message };
+			} else if (kind === "prompt") {
 				// Evidence-based empty predicate (exact-head review P1/P2): the same
 				// semantics as the noteTransition agent_end classifier. A
-				// content-bearing, activity-bearing, or explicitly stopped
-				// finalization without an explicit outcome is a successful terminal;
+				// content-bearing or activity-bearing finalization is successful;
 				// only a genuinely empty, no-activity completion fails closed.
 				const terminalText = evidence?.content?.text.trim() ?? "";
 				if (terminalText === "" && !evidence?.hasActivity && evidence?.outcomeKind !== "stopped") {
+					resolvedOutcome = canonicalFailedOutcome(EMPTY_PROMPT_FAILURE);
 					finalizedRecord.status = "failed";
 					finalizedRecord.error = EMPTY_PROMPT_FAILURE;
-				} else {
-					finalizedRecord.status = "terminal_ok";
-				}
-			} else {
-				finalizedRecord.status = "terminal_ok";
-			}
-			(finalizedRecord as unknown as Record<string, unknown>).pendingOutcome = undefined;
+				} else finalizedRecord.status = "terminal_ok";
+			} else finalizedRecord.status = "terminal_ok";
+			finalizedRecord.receiptState = reduceReceiptState(
+				finalizedRecord.receiptState,
+				reportableTurnResultContent(finalizedRecord.content) ? "present" : "unknown",
+			);
+			if (resolvedOutcome === undefined) delete finalizedRecord.outcome;
+			else finalizedRecord.outcome = resolvedOutcome;
+			delete (finalizedRecord as unknown as Record<string, unknown>).pendingOutcome;
+			delete (finalizedRecord as unknown as Record<string, unknown>).pendingReceiptState;
 			if (isCurrent !== undefined && !isCurrent()) return;
 			const commit = Promise.withResolvers<void>();
 			// This promise is an internal coordination signal for lifecycle transitions
@@ -1025,8 +1380,13 @@ export function createInvocationReconciliation(
 			};
 			if (isCurrent !== undefined && !isCurrent()) return;
 			delete next.terminalAt;
-			delete next.error;
-			delete (next as unknown as { outcome?: unknown }).outcome;
+			if (next.error?.code === "prompt_deadline_exceeded" || !isPreservedProviderFailure(next.error?.code))
+				delete next.error;
+			delete next.receiptState;
+			delete (next as unknown as { outcome?: unknown; pendingOutcome?: unknown; pendingReceiptState?: unknown })
+				.outcome;
+			delete (next as unknown as { pendingOutcome?: unknown }).pendingOutcome;
+			delete (next as unknown as { pendingReceiptState?: unknown }).pendingReceiptState;
 			(next as unknown as { deadlineRecoveryPending?: boolean }).deadlineRecoveryPending = true;
 			if (deadlineMaxAt !== undefined) (next as unknown as { deadlineMaxAt?: number }).deadlineMaxAt = deadlineMaxAt;
 			records.set(recordKey, next);
@@ -1065,6 +1425,7 @@ export interface SdkSurfaceFactoryOptions {
 	}) => unknown;
 	steerStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
 	hostTools?: boolean | (() => boolean);
+	getRuntimeHost?: () => SessionSdkHost | undefined;
 }
 
 /** Shared policy, capability, and query-surface factory for every SDK transport. */
@@ -1094,6 +1455,7 @@ function createQuerySurface(
 		}) => unknown;
 		steerStatusLookup?: (selector: { commandId?: string; turnId?: string; clientRef?: string }) => unknown;
 		hostTools?: boolean | (() => boolean);
+		getRuntimeHost?: () => SessionSdkHost | undefined;
 	} = {},
 ): SessionSurface {
 	const policy =
@@ -1117,18 +1479,15 @@ function createQuerySurface(
 		kind: ctx.sessionMetadata?.kind ?? "main",
 	});
 	const lastAssistant = () => {
-		for (const entry of ctx.sessionManager.getBranch().toReversed()) {
-			if (entry.type !== "message" || entry.message.role !== "assistant") continue;
-			const content = entry.message.content;
-			if (typeof content === "string") return content;
-			if (Array.isArray(content))
-				return content
-					.filter(
-						(block): block is { type: "text"; text: string } =>
-							block.type === "text" && typeof block.text === "string",
-					)
-					.map(block => block.text)
-					.join("");
+		const transcript =
+			typeof (ctx as Partial<ExtensionContext>).getTranscript === "function" ? ctx.getTranscript() : [];
+		for (const entry of transcript.toReversed()) {
+			if (entry.role !== "assistant") continue;
+			const text =
+				typeof entry.body === "string"
+					? entry.body
+					: entry.content?.flatMap(block => (block.type === "text" ? [block.text] : [])).join("\n");
+			if (text !== undefined && text.trim().length > 0) return text;
 		}
 		return undefined;
 	};
@@ -1500,6 +1859,28 @@ function createQuerySurface(
 			turnId?: string;
 			clientRef?: string;
 		}) => (options.turnResultLookup ?? (value => reconciliation.lookupResult(value.kind, value)))(selector),
+		getCheckpointSnapshot: () => {
+			const host = options.getRuntimeHost?.();
+			if (!host)
+				throw Object.assign(new Error("Atomic session checkpoint capture is unavailable."), {
+					code: "unavailable",
+				});
+			const entries =
+				typeof (ctx as Partial<ExtensionContext>).getTranscript === "function" ? ctx.getTranscript() : undefined;
+			if (!Array.isArray(entries))
+				throw Object.assign(new Error("Atomic session checkpoint capture is unavailable."), {
+					code: "unavailable",
+				});
+			return {
+				entries,
+				watermark: {
+					revision: entries.length,
+					generation: host.events.generation,
+					seq: host.events.sequence,
+					idle: ctx.isIdle(),
+				},
+			};
+		},
 		getSteerStatus: (selector: { commandId?: string; turnId?: string; clientRef?: string }) =>
 			(options.steerStatusLookup ?? (value => reconciliation.lookup("steer", value)))(selector),
 		getModelProfiles: async () => {
@@ -1549,6 +1930,7 @@ export function createSdkSurfaceFactory(
 		turnResultLookup: options.turnResultLookup,
 		steerStatusLookup: options.steerStatusLookup,
 		hostTools: options.hostTools,
+		getRuntimeHost: options.getRuntimeHost,
 	});
 	return {
 		policy,
@@ -1856,6 +2238,7 @@ function createControlSurface(
 	) => void,
 	canResolveGate: () => boolean = () => true,
 	trackGateResolution: <T>(resolution: Promise<T>) => Promise<T> = async resolution => await resolution,
+	onInvocationCompletionReconciledForTests?: (kind: InvocationKind, correlation: InvocationCorrelation) => void,
 ): ControlSurface {
 	const normalizePromptImages = (value: unknown): ImageContent[] => {
 		if (!Array.isArray(value)) return [];
@@ -2103,18 +2486,9 @@ function createControlSurface(
 								try {
 									await reconciliation.noteTransition(kind, correlation, {
 										type: "agent_end",
-										...(typeof result === "string"
-											? {
-													content: {
-														version: 1,
-														type: "text",
-														text: result,
-														byteLength: 0,
-														truncated: false,
-													},
-												}
-											: {}),
+										...(typeof result === "string" ? { content: sanitizeTurnResultContent(result) } : {}),
 									});
+									onInvocationCompletionReconciledForTests?.(kind, correlation);
 									retirePendingOwner?.(kind, correlation, "always");
 								} catch (transitionError) {
 									if (kind === "prompt" || kind === "skill") {
@@ -2269,7 +2643,7 @@ function createControlSurface(
 		}
 	};
 	const terminalAbort = async (
-		input: { mode: "terminal"; scope?: "turn" | "owned" },
+		input: { mode: "terminal"; scope?: "turn" | "owned"; operator?: boolean },
 		idempotencyKey?: string,
 	): Promise<unknown> => {
 		const scope = input.scope === "owned" ? "owned" : "turn";
@@ -2300,10 +2674,12 @@ function createControlSurface(
 				typeof idempotencyKey === "string"
 					? crypto.createHash("sha256").update(idempotencyKey).digest("hex")
 					: undefined;
-			const inputHash = crypto
-				.createHash("sha256")
-				.update(JSON.stringify({ mode: "terminal", scope }))
-				.digest("hex");
+			const abortIdentity = terminalAbortIdentity(
+				{ mode: "terminal", scope, ...(input.operator === true ? { operator: true } : {}) },
+				input.operator === true,
+			);
+			if (!abortIdentity) throw new Error("Terminal abort identity is invalid after dispatch validation.");
+			const inputHash = abortIdentity.inputHash;
 			const stored = (record: SdkOnlyTerminalScopeRecord | SdkOnlyEvictedTerminalKeyEntry) => ({
 				responseState: record.responseState ?? "pending",
 				responsePayloadHash: record.responsePayloadHash ?? inputHash,
@@ -2676,6 +3052,16 @@ function createControlSurface(
 						pendingPreflights.delete(requesterBucketKey);
 				}
 			};
+			const returnNoActiveTurn = async () => {
+				const result = {
+					ok: true,
+					selection: scope,
+					turn: "no_active_turn",
+					terminal: "terminal_no_effect",
+				};
+				await finalizeNoEffectReservation(result);
+				return result;
+			};
 			if (!handle || epoch === undefined) {
 				if ((await writeNoEffect()) === "conflict") {
 					throw Object.assign(new Error("Idempotency key was reused with different input."), {
@@ -2691,6 +3077,10 @@ function createControlSurface(
 					if (replayed !== undefined) return replayed;
 				}
 				cancelRequesterPreflights();
+				// Operator authority overrides connection ownership only for a turn
+				// observed at admission. It must never adopt a successor that starts
+				// while the durable no-effect reservation is being written.
+				if (input.operator === true) return await returnNoActiveTurn();
 				// A prompt for this requester may have become ACTIVE while the
 				// reservation awaited the filesystem transaction: its submit()
 				// cleanup already removed the preflight callback, so cancelling here
@@ -2706,14 +3096,7 @@ function createControlSurface(
 					// No prompt won the race: finalize the reserved row so a later
 					// same-key retry replays this deterministic no_active_turn result
 					// (review thread P2).
-					const noActiveTurnResult = {
-						ok: true,
-						selection: scope,
-						turn: "no_active_turn",
-						terminal: "terminal_no_effect",
-					};
-					await finalizeNoEffectReservation(noActiveTurnResult);
-					return noActiveTurnResult;
+					return await returnNoActiveTurn();
 				}
 				handle = recheckedHandle;
 				epoch = recheckedEpoch;
@@ -2743,7 +3126,11 @@ function createControlSurface(
 			// cleared after a terminal lifecycle boundary) authorizes no client, and
 			// a stale prior owner authorizes only that old client — never a later
 			// turn it did not submit (review thread P1).
-			if (handle && (abortingConnectionId === undefined || !currentOwnerConnectionIds().has(abortingConnectionId))) {
+			if (
+				input.operator !== true &&
+				handle &&
+				(abortingConnectionId === undefined || !currentOwnerConnectionIds().has(abortingConnectionId))
+			) {
 				if ((await writeNoEffect()) === "conflict") {
 					throw Object.assign(new Error("Idempotency key was reused with different input."), {
 						code: "idempotency_conflict",
@@ -3412,6 +3799,107 @@ export function registerSdkOnlyNotificationCommand(api: ExtensionAPI): void {
 	});
 }
 
+export function masterAttestationForEffectiveHost(input: {
+	masterCapability: string | undefined;
+	attestationEpoch: string | undefined;
+	ownerSessionId?: string;
+	sessionId: string;
+	pid: number;
+	processIncarnation: string | undefined;
+	direct: MasterRoleAttestationV2 | undefined;
+}): MasterRoleAttestationV2 | undefined {
+	const direct = input.direct;
+	if (
+		input.masterCapability === undefined ||
+		input.attestationEpoch === undefined ||
+		direct === undefined ||
+		direct.ownerSessionId !== (input.ownerSessionId ?? input.sessionId) ||
+		direct.launchPid !== input.pid ||
+		direct.launchProcessIncarnation !== input.processIncarnation ||
+		direct.attestationEpoch !== input.attestationEpoch
+	)
+		return undefined;
+	return direct;
+}
+
+function masterDirectAttestation(input: {
+	masterCapability: string | undefined;
+	attestationEpoch: string | undefined;
+	ownerSessionId?: string;
+	sessionId: string;
+	pid: number;
+	processIncarnation: string | undefined;
+}): MasterRoleAttestationV2 | undefined {
+	if (
+		input.masterCapability === undefined ||
+		input.attestationEpoch === undefined ||
+		input.processIncarnation === undefined
+	)
+		return undefined;
+	return {
+		version: 2,
+		ownerSessionId: input.ownerSessionId ?? input.sessionId,
+		launchPid: input.pid,
+		launchProcessIncarnation: input.processIncarnation,
+		role: "master",
+		attestationEpoch: input.attestationEpoch,
+	};
+}
+
+function sameMasterAttestation(left: MasterRoleAttestationV2, right: MasterRoleAttestationV2): boolean {
+	return (
+		left.version === right.version &&
+		left.ownerSessionId === right.ownerSessionId &&
+		left.launchPid === right.launchPid &&
+		left.launchProcessIncarnation === right.launchProcessIncarnation &&
+		left.role === right.role &&
+		left.attestationEpoch === right.attestationEpoch
+	);
+}
+
+/**
+ * Establish direct master authority for the session currently hosted by this
+ * process. Session identity transitions retain the master capability and epoch
+ * but require a new direct attestation before their effective endpoint can
+ * adopt that authority.
+ */
+export async function reattestMasterSessionIdentity(input: {
+	index: SessionIndex;
+	locator: SessionLocatorV2;
+	masterCapability: string | undefined;
+	attestationEpoch: string | undefined;
+	ownerSessionId?: string;
+	sessionId: string;
+	pid: number;
+	processIncarnation: string | undefined;
+}): Promise<MasterRoleAttestationV2 | undefined> {
+	const masterRole = masterDirectAttestation(input);
+	if (!masterRole) return undefined;
+	const directExists = input.index.listSessionIdentities().some(row => {
+		const processIdentity = row.hostIncarnation ?? row.processIncarnation;
+		return (
+			row.sessionId === input.sessionId &&
+			row.endpointGeneration === 0 &&
+			row.pid === input.pid &&
+			processIdentity === input.processIncarnation &&
+			row.masterRole !== undefined &&
+			sameMasterAttestation(row.masterRole, masterRole)
+		);
+	});
+	if (!directExists) {
+		await input.index.append({
+			type: "host_registered",
+			sessionId: input.sessionId,
+			locator: input.locator,
+			endpointGeneration: 0,
+			pid: input.pid,
+			processIncarnation: input.processIncarnation,
+			masterRole,
+		});
+	}
+	return masterRole;
+}
+
 function quiescingFrame(frame: Record<string, unknown>): Record<string, unknown> | undefined {
 	const error = { code: "session_quiescing", message: "The session endpoint is being replaced." };
 	const id = typeof frame.id === "string" ? frame.id : "";
@@ -3653,7 +4141,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		lifecycleOwner?: LifecycleOwner,
 		terminalContent?: TurnResultContent,
 		terminalHasActivity = false,
-		terminalOutcome?: { kind: "stopped"; reason: "cancelled"; provenance: "client_cancel" },
+		terminalOutcome?: InvocationOutcome,
 	): Promise<void> => {
 		const current = lifecycleOwner?.state ?? active;
 		if (!current) return;
@@ -3918,7 +4406,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 								? ({
 										content: terminalContent,
 										hasActivity: terminalHasActivity,
-										outcome: terminalOutcome,
+										...(terminalOutcome?.kind === "stopped" ? { outcome: terminalOutcome } : {}),
 									} satisfies PromptTerminalTransitionEvidence)
 								: undefined,
 						);
@@ -4122,7 +4610,9 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		const terminalOutcome =
 			event.stopReason === "cancelled"
 				? ({ kind: "stopped", reason: "cancelled", provenance: "client_cancel" } as const)
-				: undefined;
+				: failure === undefined
+					? undefined
+					: canonicalFailedOutcome(failure);
 		return trackLifecycle(async () => {
 			if (failure && !failureAlreadyPublished) {
 				for (const key of genericFailureKeys) owner?.failureDiagnosticKeys.delete(key);
@@ -4172,6 +4662,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		await current.registerBroker();
 		current.runtime.emitEvent({ type: "turn_start", sessionId: ctx.sessionManager.getSessionId() });
 	});
+	const consumedMasterNonces = new Map<string, number>();
 	api.on("turn_end", (_event, ctx) =>
 		lifecycleStateForContext(ctx, "agent_end")?.runtime.emitEvent({
 			type: "turn_end",
@@ -4310,6 +4801,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			});
 			await Promise.race([settled, timeout]);
 		};
+		let runtime: SessionSdkSessionRuntime;
 		const surfaceFactory = createSdkSurfaceFactory({
 			ctx,
 			id: sessionId,
@@ -4319,6 +4811,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			steerStatusLookup: selector => steerReconciliation.lookupSteer(selector),
 			configOverrides: options.configOverrides,
 			settings: options.settings,
+			getRuntimeHost: () => runtime?.host,
 		});
 		const queryHandlers = new QueryHandlers(surfaceFactory.query, sessionId, revisions, cursors);
 		const inputGate = { quiescing: false };
@@ -4375,7 +4868,6 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 				skillRecoveryControllers.delete(key);
 			});
 		};
-		let runtime: SessionSdkSessionRuntime;
 		// Durable-first bounded terminalization for accepted submissions that leave
 		// their queue or race a run WITHOUT consumption (exact-head review: clearing
 		// the lease before the durable writes strands the row accepted with no
@@ -4664,6 +5156,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			},
 			() => acceptingGateResolutions,
 			trackGateResolution,
+			options.onInvocationCompletionReconciledForTests,
 		);
 		const installProviderDefinitions = (capability: string, definitions: unknown): void => {
 			if (capability === "permission") {
@@ -4731,6 +5224,13 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		};
 		runtime = new SessionSdkSessionRuntime({
 			transport,
+			masterCapabilityVerify: frame =>
+				verifyMasterCapabilityFrame({
+					frame,
+					expectedCapability: options.masterCapability,
+					expectedEpoch: options.masterAttestationEpoch,
+					replay: consumedMasterNonces,
+				}),
 			onFrameAdmission: (_connectionId, frame) =>
 				inputGate.quiescing ? quiescingFrame(frame as Record<string, unknown>) : undefined,
 			control: async (connectionId, frame) => {
@@ -4776,21 +5276,13 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 					(request.input as { mode?: unknown }).mode !== "terminal"
 				)
 					return;
-				const input = request.input as Record<string, unknown>;
-				const mode = input.mode;
-				const rawScope = input.scope;
-				if (mode !== "terminal") return;
-				if (rawScope !== undefined && rawScope !== "turn" && rawScope !== "owned") return;
-				// A malformed retry (e.g. {mode:"terminal", scope:"turn", extra:true})
-				// rejected by dispatch must never hash as the valid turn input and
-				// advance the legitimate stored row (review thread P2).
-				for (const key of Object.keys(input)) if (key !== "mode" && key !== "scope") return;
-				const scopeInput = rawScope === "owned" ? "owned" : "turn";
+				const rawInput = request.input as Record<string, unknown>;
+				const operatorAuthorized = hasBrokerRuntimeAbortCapability(rawInput);
+				const { [BROKER_RUNTIME_ABORT_CAPABILITY_FIELD]: _capability, ...publicInput } = rawInput;
+				const abortIdentity = terminalAbortIdentity(publicInput, operatorAuthorized);
+				if (!abortIdentity) return;
 				const keyHash = crypto.createHash("sha256").update(String(request.idempotencyKey)).digest("hex");
-				const inputHash = crypto
-					.createHash("sha256")
-					.update(JSON.stringify({ mode: "terminal", scope: scopeInput }))
-					.digest("hex");
+				const inputHash = abortIdentity.inputHash;
 				// Hash the ACTUAL written response payload: the durable state may only
 				// advance when the written response corresponds to the row's payload.
 				// When more than 256 concurrent requests evict an in-flight abort from
@@ -4843,24 +5335,103 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 			},
 		});
 		if (isAutoroutingInactive(api)) markAutoroutingInactive(runtime.host);
-		const disposeGate = ctx.workflowGate?.onGateEmitted?.(gate =>
+		const disposeWorkflowGate = ctx.workflowGate?.onGateEmitted?.(gate =>
 			runtime.emitEvent({ kind: "workflow_gate", payload: gate }),
 		);
+		// Every fold (steer, chord, auto-background timer, `bash.background`)
+		// publishes one replayable `bash_folded` frame; `runtime.jobs.list`
+		// `foldReason` remains the source of truth clients reconcile against after
+		// a replay, since a replayed frame may describe a job that has since ended.
+		const disposeFold = ctx.onJobFold?.(event => {
+			try {
+				runtime.emitEvent({
+					type: "bash_folded",
+					sessionId,
+					jobId: event.jobId,
+					generation: event.generation,
+					reason: event.reason,
+				});
+			} catch (error) {
+				// The fold already happened; publication failure must not affect it,
+				// but it must leave evidence because a client relying on the event
+				// instead of runtime.jobs.list would otherwise never learn of the fold.
+				logger.warn("sdk: bash_folded publication failed", {
+					jobId: event.jobId,
+					reason: event.reason,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		});
+		const disposeGate = (): void => {
+			disposeWorkflowGate?.();
+			disposeFold?.();
+		};
+		let publishedEndpointUrl: string | undefined;
 		let brokerRegistered = false;
 		const registerBroker = async (): Promise<void> => {
 			if (brokerRegistered) return;
 			try {
+				if (options.brokerRegistrationRequired && !options.lifecycleRequestId)
+					throw new Error("Lifecycle broker registration requires a request identity.");
 				await ensureBroker({ agentDir: options.agentDir });
 				const index = await new SessionIndex(options.agentDir).open();
-				const locator = { repo: path.resolve(ctx.cwd), stateRoot };
+				const locator = await resolveSessionLocator(ctx.cwd, stateRoot);
+				const effectiveIncarnation = processIncarnation(process.pid);
+				const direct = await reattestMasterSessionIdentity({
+					index,
+					locator,
+					masterCapability: options.masterCapability,
+					attestationEpoch: options.masterAttestationEpoch,
+					ownerSessionId: options.masterOwnerSessionId,
+					sessionId,
+					pid: process.pid,
+					processIncarnation: effectiveIncarnation,
+				});
 				await runtime.registerWithBroker({
 					register: async input => {
-						const endpointMtimeMs = (await fs.stat(path.join(input.stateRoot, "sdk", `${input.sessionId}.json`)))
-							.mtimeMs;
-						await index.append({ type: "host_registered", ...input, locator, pid: process.pid, endpointMtimeMs });
+						if (publishedEndpointUrl === undefined)
+							throw new Error("SDK transport endpoint was not published before broker registration.");
+						const endpointPath = path.join(input.stateRoot, "sdk", `${input.sessionId}.json`);
+						const file = await readEndpointFile(endpointPath);
+						if (!file) throw new Error("SDK endpoint could not be read as a stable regular file.");
+						const endpoint = JSON.parse(file.source) as Record<string, unknown>;
+						if (
+							endpoint.sessionId !== input.sessionId ||
+							endpoint.pid !== process.pid ||
+							endpoint.url !== publishedEndpointUrl ||
+							endpoint.token !== transport.token
+						)
+							throw new Error("SDK endpoint did not match the published transport authority.");
+						const endpointMtimeMs = file.mtimeMs;
+						const endpointFileId = `${file.dev}:${file.ino}`;
+						const masterRole = masterAttestationForEffectiveHost({
+							masterCapability: options.masterCapability,
+							attestationEpoch: options.masterAttestationEpoch,
+							ownerSessionId: options.masterOwnerSessionId,
+							sessionId: input.sessionId,
+							pid: process.pid,
+							processIncarnation: effectiveIncarnation,
+							direct,
+						});
+						await index.append({
+							type: "host_registered",
+							...input,
+							locator,
+							pid: process.pid,
+							endpointMtimeMs,
+							endpointFileId,
+							...(options.lifecycleRequestId ? { lifecycleRequestId: options.lifecycleRequestId } : {}),
+							...(masterRole ? { masterRole } : {}),
+						});
 					},
 					unregister: async input => {
-						await index.append({ type: "host_unregistered", ...input, locator, pid: process.pid });
+						await index.append({
+							type: "host_unregistered",
+							...input,
+							locator,
+							pid: process.pid,
+							...(options.lifecycleRequestId ? { lifecycleRequestId: options.lifecycleRequestId } : {}),
+						});
 					},
 				});
 				brokerRegistered = true;
@@ -4899,7 +5470,7 @@ export function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: Cre
 		lifecycleOwnerHolder.state = runtimeOwner;
 		active = runtimeOwner;
 		try {
-			await runtime.start();
+			publishedEndpointUrl = (await runtime.start()).url;
 			await registerBroker();
 		} catch (error) {
 			active = undefined;