pi-openai-toolkit 0.23.2 → 0.24.0

package/src/extension-runtime.ts

@@ -1,7 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import { declarationsEqual, getCurrentSystemMessage, getCurrentTools } from "@earendil-works/pi-ai";
-import { convertResponsesTools } from "./context-management/responses-tools";
 import type {
 	BeforeProviderRequestEvent,
 	ContextWithSystemEvent,
@@ -13,25 +11,6 @@ import type {
 import { assertConfigValid, loadToolkitConfig, resolveToolkitConfig, type ResolvedToolkitConfig } from "./config";
 import { notifyConfigIssues } from "./config/notifications";
 import { registerToolkitConfigCommand } from "./config-command";
-import {
-	codexContextProviderHeaders,
-	resolveCodexContextProvider,
-	isCodexGatewayModel,
-	isNativeCodexModel,
-} from "./context-management/codex-provider";
-import { rewriteContextNamespaceCalls, rewriteContextNamespaceTools, routeContextNamespaceToolMessage } from "./context-management/namespace-tools";
-import { rewriteEncryptedToolOutputs } from "./context-management/window-request";
-import { loadHistoryNotesThreadHint } from "./context-management/history-notes";
-import { CodexContextWindowManager } from "./context-management/window-manager";
-import { ManagedManualCompact } from "./context-management/manual-compact";
-import { prepareScopedNativeCompaction } from "./context-management/scoped-compaction";
-import type { RemoteWindowCompactionInput } from "./context-management/window-manager";
-import { CONTEXT_WINDOW_COMPACTION_SUMMARY, isSystemTranscriptMessage } from "./context-management/messages";
-import { isRecord } from "./context-management/types";
-import {
-	registerContextManagementTools,
-	type ContextToolRegistrationState,
-} from "./context-management/tools";
 import { writeDebugArtifact, writeReplayFailureArtifact } from "./debug";
 import {
 	COMPACTION_CHECKPOINT_PROVENANCE_UNAVAILABLE,
@@ -42,7 +21,9 @@ import {
 	hasVerifiedCompactionInputProvenance,
 	type UnprojectedCompactionReason,
 } from "./compaction-projection";
-import { CODEX_GATEWAY_FORWARD_HEADERS } from "./responses-headers";
+import { buildResponsesRequestHeaders, CODEX_GATEWAY_FORWARD_HEADERS } from "./responses-headers";
+import { isExactModelAllowed } from "./model-scope";
+import { detectRetiredRemoteWindows, RETIRED_REMOTE_WINDOWS_MESSAGE } from "./retired-remote-windows";
 import { executeNativeCompaction, type NativeCompactionClientResult } from "./compact-client";
 import { qualifiesForStandaloneCompaction, type CompactionErrorInfo } from "./compaction-errors";
 import { resolveLatestNativeCompactionEntry } from "./details-store";
@@ -63,8 +44,7 @@ import { getCompactionRequestExtras, rememberRequestContext } from "./request-co
 import { resolveWebSearchRoute } from "./web-search/types";
 import { executeRemoteV2Compaction } from "./remote-v2-client";
 import {
-	rememberPhysicalModel,
-	resolveEffectiveModel,
+	registerPhysicalModelObserver,
 	resolveNativeCompactionEnvironment,
 	resolveRemoteCompactionExecution,
 	isStandaloneCompactionEligible,
@@ -83,15 +63,11 @@ import {
 	COMPACTION_EXTENSION_ID,
 	LEGACY_NATIVE_COMPACTION_STRATEGY,
 	REMOTE_V2_COMPACTION_STRATEGY,
-	NATIVE_COMPACTION_FALLBACK_SUMMARY,
-	STANDALONE_COMPACTION_FALLBACK_SUMMARY,
 	getLatestDeferredToolCarryover,
 	getRemoteV2InputProvenance,
 	isNativeCompactionDetails,
 	type CompactionConfig,
-	type DeferredToolCarryoverV1,
 	type NativeCompactionDetails,
-	type NativeCompactionEntry,
 	type NativeCompactionRequestMeta,
 } from "./types";
 
@@ -116,38 +92,52 @@ function requireContextPolicy(resolved: ResolvedToolkitConfig, ctx: ExtensionCon
 	}
 }
 
-function compactGatewayModels(resolved: ResolvedToolkitConfig): readonly string[] {
-	return resolved.format === "v2" || resolved.config.compaction.contextManagement === "remote"
-		? resolved.gatewayModelKeys : [];
-}
-
 type CompactionDependencies = {
 	loadConfig: typeof loadToolkitConfig;
 	remoteCompact: typeof executeRemoteV2Compaction;
 	standaloneCompact: typeof executeNativeCompaction;
 	nativeFallback: typeof runNativeFallbackCompaction;
-	contextWindows: CodexContextWindowManager;
-	manualCompact?: ManagedManualCompact;
-	/** Read-only fence shared by all scoped producer tiers. */
+	/** Revalidate operation ownership after awaits and at result consumption. */
 	isCurrentCompaction?: () => boolean;
 	/** Test seam for the same ordered projection exposed by the Pi host patch. */
 	projectCompactionContext?: CompactionContextProjection;
 	piContextHookPatch: PiContextHookPatchResult;
 };
 
-type RemoteContextActive = (
-	ctx: ExtensionContext,
-	config: CompactionConfig,
-	model?: ExtensionContext["model"],
-) => Promise<boolean>;
-type ContextToolRegistrationStateReader = () => ContextToolRegistrationState;
+// Notices are bounded, but every boundary freshly reads the current branch.
+const retirementNotices = new WeakMap<object, string>();
+function retirementReason(ctx: ExtensionContext): string | undefined {
+	try { return detectRetiredRemoteWindows(ctx.sessionManager.getBranch()); }
+	catch { return "branch-unavailable"; }
+}
 
-type ContextToolSyncOutcome = {
-	eligible: boolean;
-	toolsSynced: boolean;
-	registrationState: ContextToolRegistrationState;
-	windowInitialized: boolean;
-};
+function refuseRetiredSession(ctx: ExtensionContext, request = false): boolean {
+	const reason = retirementReason(ctx);
+	const owner = ctx.sessionManager;
+	if (!reason) {
+		retirementNotices.delete(owner);
+		return false;
+	}
+	const fingerprint = `${getSessionId(ctx) ?? ""}:${reason}`;
+	if (ctx.hasUI && retirementNotices.get(owner) !== fingerprint) {
+		retirementNotices.set(owner, fingerprint);
+		try {
+			ctx.ui.notify(
+				reason === "branch-unavailable"
+					? `${COMPACTION_EXTENSION_ID}: Cannot verify the active session branch; request blocked. Reopen the session before continuing.`
+					: `${COMPACTION_EXTENSION_ID}: ${RETIRED_REMOTE_WINDOWS_MESSAGE}`,
+				"error",
+			);
+		} catch {
+			// A detached UI must not prevent abort or turn compact refusal into fallback.
+		}
+	}
+	if (request) {
+		reportPiContextHookFailure(ctx, `retired-remote-windows:${reason}`);
+		ctx.abort();
+	}
+	return true;
+}
 
 type ResponsesCompactOutcome =
 	| { outcome: "success"; compaction: CompactionResult<NativeCompactionDetails> }
@@ -200,87 +190,6 @@ function notifyWarning(ctx: ExtensionContext, message: string): void {
 	}
 }
 
-async function resolveContextCapabilityModel(
-	ctx: ExtensionContext,
-	model: ExtensionContext["model"] = ctx.model,
-): Promise<ExtensionContext["model"]> {
-	const effective = await resolveEffectiveModel(ctx, model);
-	return effective.ok ? effective.model : undefined;
-}
-
-async function isRemoteContextActive(
-	ctx: ExtensionContext,
-	config: CompactionConfig,
-	model: ExtensionContext["model"] = ctx.model,
-): Promise<boolean> {
-	if (!config.enabled || config.contextManagement !== "remote") return false;
-	const resolution = await resolveCodexContextProvider(ctx, model, config.gatewayContextModels);
-	return resolution.ok;
-}
-
-function isCodexContextModel(
-	model: ExtensionContext["model"] | undefined,
-	config: CompactionConfig,
-): boolean {
-	return config.contextManagement === "remote"
-		&& (isNativeCodexModel(model) || isCodexGatewayModel(model, config.gatewayContextModels));
-}
-
-function isExcludedGatewayContext(
-	model: ExtensionContext["model"] | undefined,
-	config: CompactionConfig,
-	registrationState: ContextToolRegistrationState,
-): boolean {
-	return registrationState === "excluded" && isCodexGatewayModel(model, config.gatewayContextModels);
-}
-
-function contextManagementFailureReason(registrationState: ContextToolRegistrationState): string {
-	switch (registrationState) {
-		case "excluded":
-			return "context-tools-excluded";
-		case "conflict":
-			return "tool-name-conflict";
-		case "unverified":
-			return "tool-registration-pending";
-		case "verified":
-			return "context-management-unavailable";
-	}
-}
-
-function notifyRemoteContextFailure(ctx: ExtensionContext, reason: string): void {
-	if (ctx.hasUI) {
-		ctx.ui.notify(`${COMPACTION_EXTENSION_ID}: Remote Context management inactive (${reason})`, "warning");
-	}
-}
-
-/**
- * Surface every window trim that had to be refused to keep the tool loadout intact.
- *
- * The refusal itself is safe: the model keeps the previous turns instead of losing its
- * tools. It is still a continuity incident, so it is recorded once per window and reason
- * instead of being allowed to pass silently.
- */
-function reportProjectionDiagnostics(
-	contextWindows: CodexContextWindowManager,
-	config: CompactionConfig,
-	ctx: ExtensionContext,
-): void {
-	const diagnostics = contextWindows.takeProjectionDiagnostics();
-	if (diagnostics.length === 0) return;
-	writeDebugArtifact(
-		"compaction-event",
-		{ event: "context.projection.tool_loadout_shrink", diagnostics },
-		config,
-		ctx,
-	);
-	if (ctx.hasUI) {
-		ctx.ui.notify(
-			`${COMPACTION_EXTENSION_ID}: kept previous context to preserve tools (${diagnostics.join("; ")})`,
-			"warning",
-		);
-	}
-}
-
 function cloneOpaqueWindow(window: readonly unknown[]): unknown[] {
 	return window.map((item) => structuredClone(item));
 }
@@ -325,9 +234,8 @@ type CompactionProjectionResult =
 async function projectSessionContextForCompaction(
 	ctx: ExtensionContext,
 	projectCompactionContext: CompactionContextProjection | undefined,
-	canonicalMessages?: readonly AgentMessage[],
 ): Promise<CompactionProjectionResult> {
-	const messages = canonicalMessages ? structuredClone([...canonicalMessages]) : readSessionContextMessages(ctx);
+	const messages = readSessionContextMessages(ctx);
 	if (!messages) {
 		return { ok: false, reason: COMPACTION_SESSION_CONTEXT_UNAVAILABLE };
 	}
@@ -357,187 +265,6 @@ function getLegacySessionContextMessages(
 	];
 }
 
-type ScopedResponsesCompactInput = {
-	request: NativeCompactionRequestBody;
-	firstKeptEntryId: string;
-	deferredToolCarryover?: DeferredToolCarryoverV1;
-	requestSource: "session-context" | "non-native-session-context" | "latest-native-replay";
-	isCurrent: () => boolean;
-};
-
-/** Reject incomplete/ambiguous tool batches rather than let serialization invent results. */
-function requireCompleteCompactionToolPairs(messages: readonly AgentMessage[]): ReadonlyMap<string, string | undefined> {
-	const calls = new Map<string, string | undefined>();
-	const pending = new Set<string>();
-	for (const message of messages) {
-		if (message.role === "assistant") {
-			if (pending.size) throw new Error("compaction-tool-pair-mismatch");
-			for (const block of message.content) {
-				if (block.type !== "toolCall") continue;
-				const callId = block.id.split("|")[0];
-				if (!callId || calls.has(callId)) throw new Error("compaction-tool-pair-mismatch");
-				calls.set(callId, block.namespace);
-				pending.add(block.id);
-			}
-		} else if (message.role === "toolResult") {
-			if (!pending.delete(message.toolCallId)) throw new Error("compaction-tool-pair-mismatch");
-		} else if (pending.size && !isSystemTranscriptMessage(message)) {
-			throw new Error("compaction-tool-pair-mismatch");
-		}
-	}
-	if (pending.size) throw new Error("compaction-tool-pair-mismatch");
-	return calls;
-}
-
-/** Serialization must preserve every verified pair, with unique provider call IDs. */
-function requireCompactionWireToolPairs(input: readonly unknown[], namespaces: ReadonlyMap<string, string | undefined>): void {
-	const calls = new Set<string>();
-	const pending = new Set<string>();
-	for (const item of input) {
-		if (!isRecord(item)) throw new Error("compaction-tool-pair-mismatch");
-		if (item.type === "function_call") {
-			if (typeof item.call_id !== "string" || !namespaces.has(item.call_id) || calls.has(item.call_id)) {
-				throw new Error("compaction-tool-pair-mismatch");
-			}
-			calls.add(item.call_id);
-			pending.add(item.call_id);
-		} else if (item.type === "function_call_output") {
-			if (typeof item.call_id !== "string" || !pending.delete(item.call_id)) throw new Error("compaction-tool-pair-mismatch");
-		}
-	}
-	if (pending.size || calls.size !== namespaces.size) throw new Error("compaction-tool-pair-mismatch");
-}
-
-function requireCompactionHeadAndRetention(
-	canonical: readonly AgentMessage[],
-	projected: readonly AgentMessage[],
-	retained: readonly AgentMessage[],
-): void {
-	const before = getCurrentTools(canonical);
-	const after = getCurrentTools(projected);
-	if (!getCurrentSystemMessage(projected) || before.length !== after.length
-		|| before.some((tool, index) => !after[index] || !declarationsEqual(tool, after[index]!))) {
-		throw new Error("compaction-system-tool-head-lost");
-	}
-	// These exact source contributions will accompany the new summary in Pi.
-	// If a hook rewrites/omits one, future strict retained-copy removal cannot be proven.
-	let cursor = 0;
-	for (const message of retained) {
-		if (message.role === "custom" || message.role === "compactionSummary" || isSystemTranscriptMessage(message)) continue;
-		const index = projected.findIndex((candidate, index) => index >= cursor && isDeepStrictEqual(candidate, message));
-		if (index < 0) throw new Error("compaction-retained-context-mismatch");
-		cursor = index + 1;
-	}
-}
-
-/** Apply only pure wire adapters, never ordinary turn/history-ingest hooks. */
-function adaptCompactionWireInput(input: ResponsesInputItem[], namespaces: ReadonlyMap<string, string | undefined>): ResponsesInputItem[] {
-	// The shared legacy serializer omits namespace. Restore it from the verified
-	// canonical call before applying the existing context-router wire adapter.
-	const namespaced = input.map((item: unknown) => {
-		if (!isRecord(item) || item.type !== "function_call" || typeof item.call_id !== "string") return item;
-		const namespace = namespaces.get(item.call_id);
-		return namespace ? { ...item, namespace } : item;
-	});
-	const adapted = rewriteEncryptedToolOutputs(rewriteContextNamespaceCalls({ input: namespaced }));
-	if (!isRecord(adapted) || !Array.isArray(adapted.input)) throw new Error("compaction-wire-adaptation-failed");
-	// The adapters preserve the validated array shape, with native encrypted outputs.
-	return adapted.input as ResponsesInputItem[];
-}
-
-async function prepareScopedResponsesCompaction(
-	event: SessionBeforeCompactEvent,
-	ctx: ExtensionContext,
-	config: CompactionConfig,
-	execution: RemoteCompactionExecution,
-	dependencies: CompactionDependencies,
-	isCurrent: () => boolean,
-	prepared: RemoteWindowCompactionInput,
-): Promise<ScopedResponsesCompactInput> {
-	const windows = dependencies.contextWindows;
-	const branch = ctx.sessionManager.getBranch();
-	const provenance = getRemoteV2InputProvenance(config.remoteV2ContextSource);
-	let checkpoint: NativeCompactionEntry | undefined;
-	let requestSource: ScopedResponsesCompactInput["requestSource"] = "session-context";
-	if (prepared.owningCompaction) {
-		const latest = resolveLatestNativeCompactionEntry(branch, { baseUrl: execution.consumer.baseUrl });
-		if (latest.ok) {
-			if (latest.entry.id !== prepared.owningCompaction.id) throw new Error("compaction-owner-mismatch");
-			if (hasInvalidatedCompactionContext(branch, latest.entry.id)) throw new Error(COMPACTION_CHECKPOINT_CONTEXT_EDITED);
-			if (!hasVerifiedCompactionInputProvenance(latest.entry.details, provenance)) throw new Error(COMPACTION_CHECKPOINT_PROVENANCE_UNAVAILABLE);
-			checkpoint = latest.entry;
-			requestSource = "latest-native-replay";
-		} else {
-			if (latest.reason !== "latest-compaction-not-native" || !config.allowCompactionContinuityBreak) throw new Error("compaction-continuity-unavailable");
-			requestSource = "non-native-session-context";
-		}
-	}
-	let messages = prepared.messages;
-	if (config.remoteV2ContextSource === "pi-context-hook") {
-		const projection = await windows.withCompactionProjection(() => projectSessionContextForCompaction(
-			ctx, dependencies.projectCompactionContext, messages,
-		));
-		if (!isCurrent()) throw new Error("compaction-operation-superseded");
-		if (!projection.ok) throw new Error(projection.reason);
-		messages = windows.projectCompactionContext(projection.messages);
-	}
-	if (!isCurrent()) throw new Error("compaction-operation-superseded");
-	requireCompactionHeadAndRetention(prepared.messages, messages, prepared.retainedMessages);
-	if (checkpoint) {
-		// The synthetic Toolkit hook deliberately leaves these copies alone. Match
-		// exactly once, BEFORE encrypted-output markers change the canonical values.
-		const pruned = removeNativeCompactionRetainedMessages({
-			messages, branchEntries: branch, compactionEntry: checkpoint, expectedInputProvenance: provenance,
-		});
-		if (!pruned.ok) throw new Error(pruned.reason);
-		messages = pruned.messages;
-	}
-	const namespaces = requireCompleteCompactionToolPairs(messages);
-	const tools = getCurrentTools(messages);
-	const model = execution.compactor.currentModel;
-	const compat = isRecord(model.compat) ? model.compat : {};
-	const nativeCodex = model.api === "openai-codex-responses";
-	const encoded = windows.projectCompactionContext(messages, true);
-	let input: ResponsesInputItem[];
-	if (checkpoint) {
-		const summaryIndex = findLatestProjectedCompactionSummaryIndex(encoded, checkpoint.summary);
-		if (summaryIndex < 0 || encoded.filter((message) => message.role === "compactionSummary").length !== 1) {
-			throw new Error(COMPACTION_PROJECTED_CONTEXT_UNAVAILABLE);
-		}
-		const leading = await serializeMessagesToResponsesInputWithLimits(model, encoded.slice(0, summaryIndex));
-		if (!isCurrent()) throw new Error("compaction-operation-superseded");
-		const tail = await serializeMessagesToResponsesInputWithLimits(model, encoded.slice(summaryIndex + 1), { firstSystemMessageIsUpdate: true });
-		requireCompactionWireToolPairs([...leading, ...tail], namespaces);
-		const details = checkpoint.details;
-		if (!details) throw new Error("compaction-owner-mismatch");
-		input = [...adaptCompactionWireInput(leading, namespaces), ...(cloneOpaqueWindow(details.compactedWindow) as ResponsesInputItem[]), ...adaptCompactionWireInput(tail, namespaces)];
-	} else {
-		const serialized = await serializeMessagesToResponsesInputWithLimits(model, encoded);
-		requireCompactionWireToolPairs(serialized, namespaces);
-		input = adaptCompactionWireInput(serialized, namespaces);
-	}
-	if (!isCurrent()) throw new Error("compaction-operation-superseded");
-	const toolPayload = rewriteContextNamespaceTools({ tools: convertResponsesTools(tools, {
-		...(nativeCodex ? { strict: null } : {}),
-		supportsStrictMode: typeof compat.supportsStrictMode === "boolean" ? compat.supportsStrictMode : nativeCodex,
-		supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools === true,
-	}) }, { encrypted: true });
-	if (!isRecord(toolPayload) || !Array.isArray(toolPayload.tools)) throw new Error("compaction-wire-adaptation-failed");
-	// Current cache-stack state is authoritative; never borrow deferred metadata
-	// from an unrelated pre-window checkpoint. The canonical head proves which
-	// of those schemas are still live, including tools activated before rollover.
-	const activation = getLatestDeferredToolCarryover(branch.slice(prepared.windowBoundaryIndex)) ?? checkpoint?.details?.deferredToolCarryover;
-	const names = new Set(tools.map((tool) => tool.name));
-	const deferredToolCarryover = activation ? { ...activation, toolNames: activation.toolNames.filter((name) => names.has(name)) } : undefined;
-	return {
-		request: { model: execution.compactor.requestModel ?? execution.compactor.model, input,
-			instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions), tools: toolPayload.tools },
-		firstKeptEntryId: prepared.firstKeptEntryId,
-		deferredToolCarryover: deferredToolCarryover?.toolNames.length ? deferredToolCarryover : undefined,
-		requestSource, isCurrent,
-	};
-}
-
 async function runResponsesNativeCompact(
 	event: SessionBeforeCompactEvent,
 	ctx: ExtensionContext,
@@ -545,15 +272,13 @@ async function runResponsesNativeCompact(
 	execution: RemoteCompactionExecution,
 	remoteCompact: typeof executeRemoteV2Compaction,
 	projectCompactionContext: CompactionContextProjection | undefined,
-	/** Only ordinary compaction supplies this; managed recovery remains V2-only. */
-	standaloneCompact?: typeof executeNativeCompaction,
-	/** Window scope is independent of the ordinary producer/fallback policy. */
-	scopedInput?: ScopedResponsesCompactInput,
+	standaloneCompact: typeof executeNativeCompaction,
+	isCurrent: () => boolean,
 ): Promise<ResponsesCompactOutcome> {
 	const { consumer, compactor } = execution;
 	const instructions = buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions);
 	const branchEntries = event.branchEntries ?? ctx.sessionManager.getBranch();
-	const deferredToolCarryover = scopedInput ? scopedInput.deferredToolCarryover : getLatestDeferredToolCarryover(branchEntries);
+	const deferredToolCarryover = getLatestDeferredToolCarryover(branchEntries);
 	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
 		baseUrl: consumer.baseUrl,
 	});
@@ -561,10 +286,7 @@ async function runResponsesNativeCompact(
 	const inputProvenance = getRemoteV2InputProvenance(config.remoteV2ContextSource);
 	let requestSource: "session-context" | "non-native-session-context" | "latest-native-replay";
 	let request: NativeCompactionRequestBody;
-	if (scopedInput) {
-		request = scopedInput.request;
-		requestSource = scopedInput.requestSource;
-	} else if (latestNativeCompaction.ok) {
+	if (latestNativeCompaction.ok) {
 		if (hasInvalidatedCompactionContext(branchEntries, latestNativeCompaction.entry.id)) {
 			return { outcome: "unprojected-input", reason: COMPACTION_CHECKPOINT_CONTEXT_EDITED };
 		}
@@ -683,10 +405,10 @@ async function runResponsesNativeCompact(
 		sessionId: getSessionId(ctx),
 	}, compactor.currentModel);
 	if (extras) {
-		request = { ...request, ...extras, ...(scopedInput ? { tools: scopedInput.request.tools } : {}) };
+		request = { ...request, ...extras };
 	}
 
-	if (event.signal?.aborted || (scopedInput && !scopedInput.isCurrent())) return { outcome: "aborted" };
+	if (event.signal?.aborted || !isCurrent() || refuseRetiredSession(ctx)) return { outcome: "aborted" };
 	let protocol: "remote-v2" | "standalone-compact" = "remote-v2";
 	let compactResult: Awaited<ReturnType<typeof executeRemoteV2Compaction>> | NativeCompactionClientResult = await remoteCompact({
 		runtime: compactor,
@@ -696,7 +418,7 @@ async function runResponsesNativeCompact(
 		context: ctx,
 	});
 
-	if (scopedInput && !scopedInput.isCurrent()) return { outcome: "aborted" };
+	if (!isCurrent() || refuseRetiredSession(ctx)) return { outcome: "aborted" };
 	if (!compactResult.ok) {
 		if (compactResult.reason === "aborted" || event.signal?.aborted) return { outcome: "aborted" };
 		const tryStandalone = !!standaloneCompact && isStandaloneCompactionEligible(compactor) && qualifiesForStandaloneCompaction(compactResult);
@@ -712,7 +434,7 @@ async function runResponsesNativeCompact(
 			nextStep: tryStandalone ? "standalone-compact" : "native-summary",
 		}, config, ctx);
 		if (tryStandalone && standaloneCompact) {
-			if (event.signal?.aborted) return { outcome: "aborted" };
+			if (event.signal?.aborted || !isCurrent() || refuseRetiredSession(ctx)) return { outcome: "aborted" };
 			protocol = "standalone-compact";
 			compactResult = await standaloneCompact({ runtime: compactor, request, signal: event.signal, settings: config, context: ctx });
 		}
@@ -780,7 +502,7 @@ async function runResponsesNativeCompact(
 	}
 
 	const compaction = createNativeCompactionResult({
-		firstKeptEntryId: scopedInput?.firstKeptEntryId ?? event.preparation.firstKeptEntryId,
+		firstKeptEntryId: event.preparation.firstKeptEntryId,
 		tokensBefore: event.preparation.tokensBefore,
 		details,
 	});
@@ -815,145 +537,16 @@ async function runResponsesNativeCompact(
 		ctx,
 	);
 
-	if (scopedInput && !scopedInput.isCurrent()) return { outcome: "aborted" };
+	if (!isCurrent() || refuseRetiredSession(ctx)) return { outcome: "aborted" };
 	return { outcome: "success", compaction };
 }
 
-type ContextUnavailableCompactionResult =
-	| { compaction: CompactionResult<unknown> }
-	| { cancel: true };
-
-async function runUnavailableContextCompaction(
-	event: SessionBeforeCompactEvent,
-	ctx: ExtensionContext,
-	dependencies: CompactionDependencies,
-	resolved: ResolvedToolkitConfig,
-	config: CompactionConfig,
-	registrationState: ContextToolRegistrationState,
-): Promise<ContextUnavailableCompactionResult> {
-	const contextReason = contextManagementFailureReason(registrationState);
-	const remoteModelSpec = config.remoteCompactModel?.trim();
-	let remoteFailure: string | undefined;
-
-	if (remoteModelSpec) {
-		const resolution = await resolveRemoteCompactionExecution(
-			ctx,
-			{
-				enabled: config.enabled,
-				responsesApis: config.responsesApis,
-				codexGatewayModels: compactGatewayModels(resolved),
-			},
-			remoteModelSpec,
-		);
-		if (resolution.ok) {
-			const outcome = await runResponsesNativeCompact(
-				event,
-				ctx,
-				config,
-				resolution.execution,
-				dependencies.remoteCompact,
-				dependencies.projectCompactionContext,
-			);
-			if (outcome.outcome === "success") {
-				writeDebugArtifact(
-					"compaction-event",
-					{
-						event: "session_before_compact.context-fallback-success",
-						contextReason,
-						registrationState,
-						compactor: remoteModelSpec,
-					},
-					config,
-					ctx,
-				);
-				return { compaction: outcome.compaction };
-			}
-			if (outcome.outcome === "aborted" || outcome.outcome === "unprojected-input") {
-				return { cancel: true };
-			}
-			remoteFailure = "remote-v2-failed";
-		} else {
-			remoteFailure = resolution.reason;
-			writeDebugArtifact(
-				"compaction-event",
-				{
-					event: "session_before_compact.context-fallback-unavailable",
-					contextReason,
-					registrationState,
-					reason: resolution.reason,
-					modelSpec: remoteModelSpec,
-					errorMessage: resolution.errorMessage,
-				},
-				config,
-				ctx,
-			);
-		}
-	} else {
-		remoteFailure = "missing-remote-compaction-model";
-	}
-
-	const nativeModelSpec = config.nativeFallback.model?.trim();
-	if (config.nativeFallback.enabled && nativeModelSpec) {
-		const fallback = await dependencies.nativeFallback({
-			ctx,
-			event,
-			config,
-			modelSpec: nativeModelSpec,
-		});
-		if (fallback.ok) {
-			writeDebugArtifact(
-				"compaction-event",
-				{
-					event: "session_before_compact.context-fallback-native-success",
-					contextReason,
-					registrationState,
-					remoteFailure,
-					fallbackModel: nativeModelSpec,
-				},
-				config,
-				ctx,
-			);
-			return { compaction: fallback.result };
-		}
-		writeDebugArtifact(
-			"compaction-event",
-			{
-				event: "session_before_compact.context-fallback-native-failure",
-				contextReason,
-				registrationState,
-				remoteFailure,
-				fallbackReason: fallback.reason,
-				fallbackModel: nativeModelSpec,
-				errorMessage: fallback.errorMessage,
-			},
-			config,
-			ctx,
-		);
-	} else {
-		writeDebugArtifact(
-			"compaction-event",
-			{
-				event: "session_before_compact.context-fallback-cancelled",
-				contextReason,
-				registrationState,
-				remoteFailure,
-				reason: config.nativeFallback.enabled ? "missing-native-fallback-model" : "native-fallback-disabled",
-			},
-			config,
-			ctx,
-		);
-	}
-
-	return { cancel: true };
-}
-
 async function handleSessionBeforeCompact(
 	event: SessionBeforeCompactEvent,
 	ctx: ExtensionContext,
 	dependencies: CompactionDependencies,
-	remoteContextActive: RemoteContextActive,
-	getContextToolRegistrationState: ContextToolRegistrationStateReader,
 ) {
+	if (refuseRetiredSession(ctx)) return { cancel: true };
 	const resolved = contextOperation(dependencies.loadConfig, ctx);
 	if (resolved.invalidFeatures.some((feature) => ["context", "compatibility", "diagnostics"].includes(feature))) return { cancel: true };
 	const config = resolved.config.compaction;
@@ -980,67 +573,9 @@ async function handleSessionBeforeCompact(
 		return { cancel: true };
 	}
 
-	// Window ownership survives model-policy changes, including Pi/disabled mode.
-	// Resolve it before any ordinary or default compactor can receive this input.
-	try {
-		dependencies.contextWindows.synchronize(ctx);
-	} catch {
-		notifyRemoteContextFailure(ctx, "malformed-window-state");
-		return { cancel: true };
-	}
-
-	// A rollover trim is owned maintenance, not user /compact.
-	if (dependencies.manualCompact?.isMaintenance) return dependencies.contextWindows.prepareCompaction(event);
-
-	// Preserve the existing automatic Remote Windows protocol. Manual operations
-	// select their engine by current policy, never by persisted marker ownership.
-	if (event.reason !== "manual" && config.enabled && config.contextManagement === "remote") {
-		const contextModel = await resolveContextCapabilityModel(ctx);
-		if (isCodexContextModel(contextModel, config)) {
-			if (await remoteContextActive(ctx, config, contextModel)) return dependencies.contextWindows.prepareCompaction(event);
-			return runUnavailableContextCompaction(event, ctx, dependencies, resolved, config, getContextToolRegistrationState());
-		}
-	}
-
-	const isCurrent = dependencies.isCurrentCompaction ?? (() => !event.signal.aborted);
-	let scope: RemoteWindowCompactionInput | undefined;
-	if (dependencies.contextWindows.currentIdentity()) {
-		scope = dependencies.contextWindows.prepareRemoteCompaction(event, ctx);
-		requireCompleteCompactionToolPairs(scope.messages);
-		event = prepareScopedNativeCompaction(event, scope);
-		const keptIndex = event.branchEntries.findIndex((entry) => entry.id === event.preparation.firstKeptEntryId);
-		scope = { ...scope, firstKeptEntryId: event.preparation.firstKeptEntryId,
-			retainedMessages: scope.entries.filter((entry) => entry.sourceEntry.type !== "compaction"
-				&& event.branchEntries.findIndex((raw) => raw.id === entry.sourceEntry.id) >= keptIndex)
-				.flatMap((entry) => entry.messages) };
-		if (!isCurrent()) return { cancel: true };
-	}
-	const nativeScopeSafe = () => {
-		if (scope && !event.preparation.messagesToSummarize.length && !event.preparation.turnPrefixMessages.length && !event.preparation.previousSummary) {
-			notifyWarning(ctx, "Current window has no eligible native summary span; context preserved.");
-			return false;
-		}
-		const owner = scope?.owningCompaction;
-		if (!owner) return true;
-		const opaque = owner.summary === NATIVE_COMPACTION_FALLBACK_SUMMARY || owner.summary === STANDALONE_COMPACTION_FALLBACK_SUMMARY
-			|| (isRecord(owner.details) && (owner.details.strategy === REMOTE_V2_COMPACTION_STRATEGY || owner.details.strategy === LEGACY_NATIVE_COMPACTION_STRATEGY));
-		if (!opaque) return true;
-		// Pi's text summarizer cannot interpret a Toolkit encrypted checkpoint.
-		// Replacing it with a summary of its sentinel would silently lose history.
-		notifyWarning(ctx, "Native compression cannot merge the current encrypted checkpoint; context preserved.");
-		return false;
-	};
-	const nativeDefault = async () => {
-		if (!scope) return undefined;
-		if (!nativeScopeSafe()) return { cancel: true };
-		const result = await dependencies.nativeFallback({ ctx, event, config, scoped: true, useCurrentModel: true, isCurrent });
-		if (!isCurrent() || !result.ok) {
-			if (!result.ok) notifyWarning(ctx, `Current-window native compression stopped (${result.reason}); context preserved.`);
-			return { cancel: true };
-		}
-		return { compaction: result.result };
-	};
-	if (!config.enabled || resolved.policy.context.mode !== "remote-compaction") return nativeDefault();
+	const isCurrent = dependencies.isCurrentCompaction ?? (() => true);
+	if (!isCurrent()) return { cancel: true };
+	if (!config.enabled || resolved.policy.context.mode !== "remote-compaction") return undefined;
 
 	// Resolve producer protocol policy from this operation's document, not a later disk read.
 	if (resolved.format === "v2" && config.remoteCompactModel) {
@@ -1058,13 +593,12 @@ async function handleSessionBeforeCompact(
 		{
 			enabled: config.enabled,
 			responsesApis: config.responsesApis,
-			codexGatewayModels: compactGatewayModels(resolved),
+			codexGatewayModels: resolved.gatewayModelKeys,
 		},
 		config.remoteCompactModel,
 	);
-	if (scope && !isCurrent()) return { cancel: true };
+	if (!isCurrent() || event.signal.aborted || refuseRetiredSession(ctx)) return { cancel: true };
 	if (resolution.ok) {
-		const scopedInput = scope ? await prepareScopedResponsesCompaction(event, ctx, config, resolution.execution, dependencies, isCurrent, scope) : undefined;
 		remoteAttempted = true;
 		const responsesOutcome = await runResponsesNativeCompact(
 			event,
@@ -1074,8 +608,9 @@ async function handleSessionBeforeCompact(
 			dependencies.remoteCompact,
 			dependencies.projectCompactionContext,
 			dependencies.standaloneCompact,
-			scopedInput,
+			isCurrent,
 		);
+		if (!isCurrent() || refuseRetiredSession(ctx)) return { cancel: true };
 		if (responsesOutcome.outcome === "success") {
 			return { compaction: responsesOutcome.compaction };
 		}
@@ -1152,9 +687,9 @@ async function handleSessionBeforeCompact(
 	// Branch 2: run pi's native compaction method. A failed remote request is compacted by the
 	// remote producer itself; a model that cannot use remote v2 at all uses nativeFallback.model.
 	const fallbackModelSpec = remoteAttempted ? config.remoteCompactModel : config.nativeFallback.model;
-	if (scope && !nativeScopeSafe()) return { cancel: true };
-	const fallback = await dependencies.nativeFallback({ ctx, event, config, modelSpec: fallbackModelSpec, ...(scope ? { scoped: true, isCurrent } : {}) });
-	if (scope && !isCurrent()) return { cancel: true };
+	if (!isCurrent() || event.signal.aborted || refuseRetiredSession(ctx)) return { cancel: true };
+	const fallback = await dependencies.nativeFallback({ ctx, event, config, modelSpec: fallbackModelSpec, isCurrent });
+	if (!isCurrent() || refuseRetiredSession(ctx)) return { cancel: true };
 	if (fallback.ok) {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
@@ -1205,160 +740,31 @@ async function handleSessionBeforeCompact(
 		return { cancel: true };
 	}
 
-	// An unscoped undefined handoff would reopen archived windows. A scoped
-	// current-model selection uses the public native primitive instead.
-	return nativeDefault();
-}
-
-function rejectInheritedCheckpointReplay(
-	ctx: ExtensionContext,
-	config: CompactionConfig,
-	compactionEntryId: string,
-	reason: string,
-): undefined {
-	writeReplayFailureArtifact({ reason, compactionEntryId }, config, ctx);
-	reportPiContextHookFailure(ctx, `replay-failed:${reason}`);
-	if (ctx.hasUI) ctx.ui.notify(`${COMPACTION_EXTENSION_ID}: inherited checkpoint replay failed (${reason}); request aborted`, "error");
-	ctx.abort();
 	return undefined;
 }
 
 async function handleContextInternal(
 	event: ContextWithSystemEvent,
 	ctx: ExtensionContext,
-	pi: ExtensionAPI,
 	loadConfig: typeof loadToolkitConfig,
-	contextWindows: CodexContextWindowManager,
-	remoteContextActive: RemoteContextActive,
-	getContextToolRegistrationState: ContextToolRegistrationStateReader,
 ) {
+	if (refuseRetiredSession(ctx, true)) return undefined;
 	const resolved = contextOperation(loadConfig, ctx);
 	requireContextPolicy(resolved, ctx);
 	const config = resolved.config.compaction;
-	try {
-		contextWindows.synchronize(ctx);
-	} catch {
-		notifyRemoteContextFailure(ctx, "malformed-window-state");
-		reportPiContextHookFailure(ctx, "malformed-window-state");
-		ctx.abort();
-		return undefined;
-	}
-
-	// A synthetic compression projection is read-only in EVERY mode. The
-	// caller performs the sole retained-copy match after all ordered hooks;
-	// ordinary replay here would remove the same copies a second time.
-	if (contextWindows.isPreparingCompaction) return { messages: contextWindows.projectCompactionContext(event.messages) };
-
-	let localMessages: AgentMessage[] | undefined;
-	let remoteReplayProjection = false;
-	// Disabled and intentionally downgraded runtimes never enter opaque replay,
-	// but still honor a window already owned by this session.
-	let localProjectionOnly = !config.enabled;
-	if (config.enabled && config.contextManagement === "remote") {
-		const contextModel = await resolveContextCapabilityModel(ctx);
-		const remoteActive = await remoteContextActive(ctx, config, contextModel);
-		if (remoteActive) {
-			try {
-				// Measure the provider-visible current window, not Pi's durable transcript.
-				// The latter still contains retired remote windows and can be inflated by
-				// an upstream error even though this request only carries the live window.
-				let projected = contextWindows.project(event.messages, "remote", false);
-				// Projection may observe the exact queued rollover before Pi persists
-				// it. Decide replay ownership from this request, not the old branch.
-				const ownsWindow = contextWindows.hasEffectiveWindow() || !contextWindows.currentIdentity();
-				if (ownsWindow) projected = contextWindows.project(projected, "remote");
-				contextWindows.recordBudget(
-					pi,
-					ctx,
-					true,
-					config.contextReminderThresholdPercent,
-				);
-				reportProjectionDiagnostics(contextWindows, config, ctx);
-				if (ownsWindow) {
-					return projected.length === event.messages.length && projected.every((message, index) => message === event.messages[index])
-						? undefined
-						: { messages: projected };
-				}
-				localMessages = projected;
-				remoteReplayProjection = true;
-			} catch (error) {
-				notifyRemoteContextFailure(ctx, "malformed-window-state");
-				reportPiContextHookFailure(ctx, "malformed-window-state");
-				ctx.abort();
-				return undefined;
-			}
-		}
-
-		// An unavailable covered runtime must not silently become an ordinary
-		// replay consumer. Explicit host exclusion remains the one intentional
-		// downgrade; active Remote can replay a newer inherited checkpoint.
-		if (!remoteActive && isCodexContextModel(contextModel, config)) {
-			const registrationState = getContextToolRegistrationState();
-			if (!isExcludedGatewayContext(contextModel, config, registrationState)
-				&& isCodexGatewayModel(contextModel, config.gatewayContextModels)) {
-				const reason = contextManagementFailureReason(registrationState);
-				notifyRemoteContextFailure(ctx, reason);
-				reportPiContextHookFailure(ctx, reason);
-				ctx.abort();
-				return undefined;
-			}
-			localProjectionOnly = true;
-		}
-	}
-
-	if (!remoteReplayProjection) {
-		try {
-			const projected = contextWindows.project(event.messages, "local");
-			localMessages = projected;
-			if (localProjectionOnly || contextWindows.hasEffectiveWindow()) {
-				// A persisted boundary owns earlier history regardless of the selected
-				// mode. Neither disabled policy nor ordinary replay may expand it.
-				return projected.length === event.messages.length && projected.every((message, index) => message === event.messages[index])
-					? undefined
-					: { messages: projected };
-			}
-		} catch (error) {
-			notifyRemoteContextFailure(ctx, "malformed-window-state");
-			reportPiContextHookFailure(ctx, error instanceof Error ? error.message : String(error));
-			ctx.abort();
-			return undefined;
-		}
-	}
-
-	// Without an effective Remote boundary, the latest checkpoint owns replay.
-	// This also covers a newer checkpoint superseding a historical window.
-	const visibleMessages = localMessages ?? contextWindows.project(event.messages, "off");
-	const finishProjection = (messages: AgentMessage[]) => {
-		// Compare canonical retained copies before Remote encrypted-output encoding.
-		const projected = remoteReplayProjection ? contextWindows.project(messages, "remote") : messages;
-		return projected.length === event.messages.length && projected.every((message, index) => message === event.messages[index])
-			? undefined : { messages: projected };
-	};
-	const replayEvent = visibleMessages === event.messages ? event : { ...event, messages: visibleMessages };
+	if (!config.enabled) return undefined;
 	const branchEntries = ctx.sessionManager.getBranch();
-	const inherited = config.contextManagement === "remote" && contextWindows.hasSupersededWindow()
-		? resolveLatestNativeCompactionEntry(branchEntries) : undefined;
-	const inheritedCheckpoint = inherited?.ok ? inherited.entry : undefined;
 	const resolution = await resolveNativeCompactionEnvironment(ctx, {
 		enabled: config.enabled,
-		// Disabling checkpoint generation cannot turn an inherited opaque
-		// checkpoint into a usable text summary. Replay checks transport support.
-		responsesApis: inheritedCheckpoint ? undefined : config.responsesApis,
-		codexGatewayModels: compactGatewayModels(resolved),
+		responsesApis: config.responsesApis,
+		codexGatewayModels: resolved.gatewayModelKeys,
 	});
-	if (!resolution.ok) {
-		return inheritedCheckpoint
-			? rejectInheritedCheckpointReplay(ctx, config, inheritedCheckpoint.id, resolution.reason)
-			: finishProjection(visibleMessages);
-	}
+	if (refuseRetiredSession(ctx, true)) return undefined;
+	if (!resolution.ok) return undefined;
 	const latest = resolveLatestNativeCompactionEntry(branchEntries, { baseUrl: resolution.runtime.baseUrl });
-	if (!latest.ok) {
-		return inheritedCheckpoint
-			? rejectInheritedCheckpointReplay(ctx, config, inheritedCheckpoint.id, latest.reason)
-			: finishProjection(visibleMessages);
-	}
+	if (!latest.ok) return undefined;
 	const result = removeNativeCompactionRetainedMessages({
-		messages: replayEvent.messages,
+		messages: event.messages,
 		branchEntries,
 		compactionEntry: latest.entry,
 		expectedInputProvenance: getRemoteV2InputProvenance(config.remoteV2ContextSource),
@@ -1370,7 +776,8 @@ async function handleContextInternal(
 		ctx.abort();
 		return undefined;
 	}
-	return finishProjection(result.messages);
+	return result.messages.length === event.messages.length && result.messages.every((message, index) => message === event.messages[index])
+		? undefined : { messages: result.messages };
 }
 
 /**
@@ -1381,14 +788,10 @@ async function handleContextInternal(
 async function handleContext(
 	event: ContextWithSystemEvent,
 	ctx: ExtensionContext,
-	pi: ExtensionAPI,
 	loadConfig: typeof loadToolkitConfig,
-	contextWindows: CodexContextWindowManager,
-	remoteContextActive: RemoteContextActive,
-	getContextToolRegistrationState: ContextToolRegistrationStateReader,
 ) {
 	try {
-		return await handleContextInternal(event, ctx, pi, loadConfig, contextWindows, remoteContextActive, getContextToolRegistrationState);
+		return await handleContextInternal(event, ctx, loadConfig);
 	} catch (error) {
 		reportPiContextHookFailure(ctx, error instanceof Error ? error.message : String(error));
 		throw error;
@@ -1399,78 +802,21 @@ async function handleBeforeProviderRequest(
 	event: BeforeProviderRequestEvent,
 	ctx: ExtensionContext,
 	loadConfig: typeof loadToolkitConfig,
-	contextWindows: CodexContextWindowManager,
-	remoteContextActive: RemoteContextActive,
-	getContextToolRegistrationState: ContextToolRegistrationStateReader,
 ) {
+	if (refuseRetiredSession(ctx, true)) return undefined;
 	const resolved = contextOperation(loadConfig, ctx);
 	requireContextPolicy(resolved, ctx);
 	const toolkitConfig = resolved.config;
 	const config = toolkitConfig.compaction;
-	try {
-		contextWindows.synchronize(ctx);
-	} catch {
-		notifyRemoteContextFailure(ctx, "malformed-window-state");
-		ctx.abort();
-		return undefined;
-	}
-	if (!config.enabled) {
-		return undefined;
-	}
-
-	const contextModel = config.contextManagement === "remote"
-		? await resolveContextCapabilityModel(ctx)
-		: undefined;
-	const remoteActive = config.contextManagement === "remote" && await remoteContextActive(ctx, config, contextModel);
-	let remotePayload: unknown;
-	let activeWindowPayload = false;
-	if (remoteActive) {
-		try {
-			remotePayload = contextWindows.rewritePayload(event.payload, ctx);
-			activeWindowPayload = contextWindows.hasEffectiveWindow() || !contextWindows.currentIdentity();
-			event = { ...event, payload: remotePayload };
-		} catch {
-			notifyRemoteContextFailure(ctx, "malformed-request-state");
-			ctx.abort();
-			return undefined;
-		}
-	}
-	if (!remoteActive && isCodexContextModel(contextModel, config)) {
-		const registrationState = getContextToolRegistrationState();
-		// A readable empty registry is an intentional host exclusion. Do not
-		// rewrite gateway identity or abort an ordinary child-session request.
-		if (isExcludedGatewayContext(contextModel, config, registrationState)) return undefined;
-		// Keep Codex Remote mutually exclusive with the legacy replay pipeline
-		// when authentication or tool ownership is unavailable. Gateway traffic
-		// cannot continue as an ordinary Responses request because that would
-		// silently lose the required CPA session/account selection.
-		if (isCodexGatewayModel(contextModel, config.gatewayContextModels)) {
-			const reason = contextManagementFailureReason(registrationState);
-			notifyRemoteContextFailure(ctx, reason);
-			ctx.abort();
-		}
-		return undefined;
-	}
-
-	// Do not reintroduce a pre-window opaque checkpoint after local projection.
-	// Request affinity/encrypted-output rewriting is reserved for active Remote.
-	if (contextWindows.hasEffectiveWindow() && !activeWindowPayload) return undefined;
-
+	if (!config.enabled) return undefined;
+	const resolution = await resolveNativeCompactionEnvironment(ctx, {
+		enabled: config.enabled,
+		responsesApis: config.responsesApis,
+		codexGatewayModels: resolved.gatewayModelKeys,
+	}, event.payload);
+	if (refuseRetiredSession(ctx, true)) return undefined;
 	const branchEntries = ctx.sessionManager.getBranch();
-	const inherited = !activeWindowPayload && config.contextManagement === "remote" && contextWindows.hasSupersededWindow()
-		? resolveLatestNativeCompactionEntry(branchEntries) : undefined;
-	const inheritedCheckpoint = inherited?.ok ? inherited.entry : undefined;
-	const resolution = await resolveNativeCompactionEnvironment(
-		ctx,
-		{
-			enabled: config.enabled,
-			responsesApis: inheritedCheckpoint ? undefined : config.responsesApis,
-			codexGatewayModels: compactGatewayModels(resolved),
-		},
-		event.payload,
-	);
 	if (resolution.ok === false) {
-		if (inheritedCheckpoint) return rejectInheritedCheckpointReplay(ctx, config, inheritedCheckpoint.id, resolution.reason);
 		writeDebugArtifact(
 			"provider-request",
 			{
@@ -1487,7 +833,7 @@ async function handleBeforeProviderRequest(
 			config,
 			ctx,
 		);
-		return remotePayload;
+		return undefined;
 	}
 
 	const runtime = resolution.runtime;
@@ -1515,15 +861,10 @@ async function handleBeforeProviderRequest(
 		},
 	);
 
-	// Capture is pre-Web-Search metadata only. An effective Remote window still
-	// owns this live payload and must NEVER enter ordinary opaque replay below.
-	if (activeWindowPayload) return remotePayload;
-
 	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
 		baseUrl: runtime.baseUrl,
 	});
 	if (!latestNativeCompaction.ok) {
-		if (inheritedCheckpoint) return rejectInheritedCheckpointReplay(ctx, config, inheritedCheckpoint.id, latestNativeCompaction.reason);
 		writeDebugArtifact(
 			"provider-request",
 			{
@@ -1541,7 +882,7 @@ async function handleBeforeProviderRequest(
 			config,
 			ctx,
 		);
-		return remotePayload;
+		return undefined;
 	}
 
 	const latestNativeCompactionEntry = latestNativeCompaction.entry;
@@ -1629,291 +970,126 @@ export default function registerCompactionExtension(
 ) {
 	const loadConfig = overrides.loadConfig ?? loadToolkitConfig;
 	registerToolkitConfigCommand(pi, loadConfig);
+	registerPhysicalModelObserver(pi);
 	const piContextHookPatch = installPiContextHookPatch();
-	const contextWindows = overrides.contextWindows ?? new CodexContextWindowManager((ctx, signal, gatewayModels) =>
-		loadHistoryNotesThreadHint(ctx, signal, gatewayModels)
-	);
-	const manualCompact = new ManagedManualCompact(pi);
 	let compactionGeneration = 0;
 	const invalidateCompaction = () => { compactionGeneration++; };
 	const dependencies: CompactionDependencies = {
 		remoteCompact: executeRemoteV2Compaction,
 		standaloneCompact: executeNativeCompaction,
 		nativeFallback: runNativeFallbackCompaction,
-		contextWindows,
 		...overrides,
-		manualCompact,
 		loadConfig,
 		piContextHookPatch: overrides.piContextHookPatch ?? piContextHookPatch,
 	};
-	let tools!: ReturnType<typeof registerContextManagementTools>;
-	let contextWindowReady = false;
-	const isContextRuntimeActive = async (
-		ctx: ExtensionContext,
-		config: CompactionConfig,
-		model = ctx.model,
-	): Promise<boolean> =>
-		contextWindowReady && tools.isRegistered && await isRemoteContextActive(ctx, config, model);
-	tools = registerContextManagementTools(
-		pi,
-		contextWindows,
-		async (ctx) => {
-			const resolved = contextOperation(dependencies.loadConfig, ctx);
-			assertConfigValid(resolved, "context", "compatibility");
-			return { active: await isContextRuntimeActive(ctx, resolved.config.compaction), gatewayModels: resolved.gatewayModelKeys };
-		},
-		undefined,
-		manualCompact,
-	);
-	const remoteContextActive: RemoteContextActive = isContextRuntimeActive;
-	const syncTools = async (
-		ctx: ExtensionContext,
-		model = ctx.model,
-		options: { notifyWindowFailure?: boolean } = {},
-		resolved = contextOperation(dependencies.loadConfig, ctx, model),
-	): Promise<ContextToolSyncOutcome> => {
-		// Until this call proves otherwise, do not let a previous session/window
-		// identity make a failed activation look usable.
-		contextWindowReady = false;
-		const config = resolved.config.compaction;
-		const eligible = !resolved.invalidFeatures.some((feature) => ["context", "compatibility"].includes(feature)) && await isRemoteContextActive(ctx, config, model);
-		const toolSync = tools.sync(eligible);
-		const outcome: ContextToolSyncOutcome = {
-			eligible,
-			toolsSynced: toolSync.synced,
-			registrationState: toolSync.registrationState,
-			windowInitialized: false,
-		};
-		if (!eligible || !toolSync.synced) return outcome;
-		// Activation can succeed after `session_start` missed it, because Pi 0.86 may
-		// reject the registration read while a session replacement is still binding.
-		// The window lifecycle has to open on that later activation too, or requests
-		// carry no window metadata and the backend never ingests the turns.
-		try {
-			contextWindows.ensureInitialized(pi, ctx, true);
-			contextWindowReady = true;
-			return { ...outcome, windowInitialized: true };
-		} catch {
-			// Do not leave tools exposed while the request path has no valid window
-			// identity. The next lifecycle hook may retry once Pi is usable again.
-			tools.sync(false);
-			if (options.notifyWindowFailure) notifyRemoteContextFailure(ctx, "malformed-window-state");
-			return outcome;
-		}
-	};
-	pi.on("session_start", async (_event, ctx) => {
+	pi.on("session_start", (_event, ctx) => {
 		invalidateCompaction();
-		const resolved = contextOperation(dependencies.loadConfig, ctx);
-		const syncOutcome = await syncTools(ctx, ctx.model, { notifyWindowFailure: true }, resolved);
-		await manualCompact.recover(ctx);
-		const active = syncOutcome.eligible && syncOutcome.toolsSynced && syncOutcome.windowInitialized;
-		const { source } = resolved;
-		const warnings = resolved.issues.map((issue) => `${issue.path}: ${issue.code}`);
+		if (refuseRetiredSession(ctx)) return;
+		const resolved = contextOperation(loadConfig, ctx);
 		const config = resolved.config.compaction;
-		if (resolved.invalidFeatures.length > 0) return;
-		if (!config.enabled) return;
-		const contextModel = await resolveContextCapabilityModel(ctx);
-
-		let activationReason: string | undefined;
-		// Only models the built-in Remote Context coverage targets may activate or
-		// warn; everything else silently runs Pi's normal compaction path.
-		if (config.contextManagement === "remote" && isCodexContextModel(contextModel, config) && !active) {
-			if (syncOutcome.registrationState === "excluded") {
-				activationReason = "context-tools-excluded";
-			} else if (syncOutcome.registrationState === "conflict") {
-				activationReason = "tool-name-conflict";
-				notifyRemoteContextFailure(ctx, activationReason);
-			} else if (syncOutcome.registrationState === "unverified" || !syncOutcome.toolsSynced) {
-				// Transient: the runtime has not published or accepted our tools yet. A
-				// later before_agent_start re-verifies, so do not report provider failure.
-				activationReason = "tool-registration-pending";
-			} else if (syncOutcome.eligible && !syncOutcome.windowInitialized) {
-				activationReason = "malformed-window-state";
-			} else {
-				const remoteResolution = await resolveCodexContextProvider(ctx, ctx.model, config.gatewayContextModels);
-				activationReason = remoteResolution.ok ? "codex-context-unavailable" : remoteResolution.reason;
-				notifyRemoteContextFailure(ctx, activationReason);
-			}
-		}
-
-
-		const artifactPath = writeDebugArtifact(
-			"lifecycle",
-			{
-				event: "session_start",
-				config,
-				configSource: source,
-				warnings,
-				activation: {
-					active,
-					contextManagement: config.contextManagement,
-					remoteV2ContextSource: config.remoteV2ContextSource,
-					model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
-					...(activationReason ? { reason: activationReason } : {}),
-				},
-				piContextHookPatch: dependencies.piContextHookPatch,
-			},
-			config,
-			ctx,
-		);
-
+		if (resolved.invalidFeatures.length || !config.enabled) return;
+		const artifactPath = writeDebugArtifact("lifecycle", {
+			event: "session_start", config, configSource: resolved.source,
+			warnings: resolved.issues.map((issue) => `${issue.path}: ${issue.code}`),
+			piContextHookPatch: dependencies.piContextHookPatch,
+		}, config, ctx);
 		if (ctx.hasUI && ["info", "debug"].includes(resolved.policy.diagnostics.level) && (config.notifyOnLoad || config.debug)) {
-			ctx.ui.notify(
-				artifactPath
-					? `${COMPACTION_EXTENSION_ID} loaded • debug artifacts → ${artifactPath}`
-					: `${COMPACTION_EXTENSION_ID} loaded`,
-				"info",
-			);
+			ctx.ui.notify(artifactPath ? `${COMPACTION_EXTENSION_ID} loaded • debug artifacts → ${artifactPath}` : `${COMPACTION_EXTENSION_ID} loaded`, "info");
 		}
 	});
-
-	const getContextToolRegistrationState: ContextToolRegistrationStateReader = () => tools.registrationState;
-	pi.on("context_with_system", (event, ctx) => {
-		manualCompact.guardRequest(ctx);
-		return handleContext(event, ctx, pi, dependencies.loadConfig, contextWindows, remoteContextActive, getContextToolRegistrationState);
+	pi.on("session_tree", (_event, ctx) => {
+		invalidateCompaction();
+		refuseRetiredSession(ctx);
 	});
+	pi.on("context_with_system", (event, ctx) => handleContext(event, ctx, loadConfig));
+	pi.on("before_provider_request", (event, ctx) => handleBeforeProviderRequest(event, ctx, loadConfig));
 	pi.on("session_before_compact", async (event, ctx) => {
 		invalidateCompaction();
-		const generation = compactionGeneration;
-		const branch = structuredClone(event.branchEntries);
-		const sessionId = getSessionId(ctx);
-		const model = ctx.model ? { ...ctx.model } : undefined;
-		const thinking = ctx.thinkingLevel;
-		const isCurrent = () => generation === compactionGeneration && !event.signal.aborted
-			&& getSessionId(ctx) === sessionId && isDeepStrictEqual(branch, ctx.sessionManager.getBranch())
-			&& isDeepStrictEqual(model, ctx.model)
-			&& thinking === ctx.thinkingLevel
-			&& !(event.reason === "manual" && typeof ctx.hasPendingMessages === "function" && ctx.hasPendingMessages());
+		if (refuseRetiredSession(ctx)) return { cancel: true };
 		try {
-			const result = await handleSessionBeforeCompact(event, ctx, { ...dependencies, isCurrentCompaction: isCurrent }, remoteContextActive, getContextToolRegistrationState);
-			if (contextWindows.currentIdentity() && !manualCompact.isMaintenance && result && "compaction" in result && result.compaction
-				&& result.compaction.summary !== CONTEXT_WINDOW_COMPACTION_SUMMARY) {
-				// Pi consumes this after every later before-compact observer. Reject
-				// stale work then, without broad aborts that can drain host queues.
+			const generation = compactionGeneration;
+			const branch = structuredClone(ctx.sessionManager.getBranch());
+			const sessionId = getSessionId(ctx);
+			const model = ctx.model ? { ...ctx.model } : undefined;
+			const thinking = ctx.thinkingLevel;
+			// Clients classify aborts. This fence handles stale ownership: a
+			// validated V2 terminal still wins over cleanup-triggered cancellation.
+			const isCurrent = () => {
+				try {
+					return generation === compactionGeneration
+						&& getSessionId(ctx) === sessionId && isDeepStrictEqual(branch, ctx.sessionManager.getBranch())
+						&& isDeepStrictEqual(model, ctx.model) && thinking === ctx.thinkingLevel
+						&& !retirementReason(ctx)
+						&& !(event.reason === "manual" && typeof ctx.hasPendingMessages === "function" && ctx.hasPendingMessages());
+				} catch { return false; }
+			};
+			const result = await handleSessionBeforeCompact(event, ctx, { ...dependencies, isCurrentCompaction: isCurrent });
+			if (!isCurrent()) return { cancel: true };
+			if (result && "compaction" in result && result.compaction) {
+				// Pi consumes results after later awaited observers. Never persist a
+				// stale candidate or drain/consume the host's queues.
 				return { compaction: result.compaction, get cancel() { return !isCurrent(); } };
 			}
+			if (result === undefined) {
+				// Default summarization starts only after later observers finish too.
+				// Keep the host handoff revocable without claiming its compaction.
+				return { get cancel() { return !isCurrent(); } };
+			}
 			return result;
 		} catch {
-			// Pi treats a rejected hook as absent and can invoke its implicit summary.
-			// Unexpected preparation/service failures must never authorize that work.
+			// Pi can treat a rejected hook as absent and run its implicit summary.
 			try { notifyWarning(ctx, "Compaction stopped; existing context preserved. Resume manually."); } catch { /* stale UI */ }
 			return { cancel: true };
 		}
 	});
-	pi.on("session_compact", (event, ctx) => {
-		contextWindows.synchronize(ctx);
-		invalidateCompaction();
-	});
+	pi.on("session_compact", invalidateCompaction);
 	pi.on("session_compact_failed", invalidateCompaction);
-	pi.on("session_shutdown", async (_event, ctx) => {
-		invalidateCompaction();
-		await manualCompact.shutdown(ctx);
-		contextWindowReady = false;
-		contextWindows.reset();
-		tools.reset();
-	});
-	pi.on("agent_settled", async (_event, ctx) => {
-		// Only the owned manual handoff restores/continues here; Pi owns normal
-		// compaction scheduling. Never compact retired windows on model changes.
-		await manualCompact.settled(ctx);
-	});
-	pi.on("model_select", async (event, ctx) => {
-		invalidateCompaction();
-		manualCompact.modelSelected(event.model, ctx);
-		// Switching into a covered model mid-session must open the window
-		// lifecycle immediately: without an identity the request rewrite skips
-		// window metadata, the backend never ingests those turns, and the first
-		// new_context would trim pre-switch history that no history can recover.
-		// syncTools() activates and initializes the window when the model is covered.
-		const resolved = contextOperation(dependencies.loadConfig, ctx, event.model);
-		await syncTools(ctx, event.model, { notifyWindowFailure: true }, resolved);
-	});
-	pi.on("before_agent_start", async (_event, ctx) => {
-		invalidateCompaction();
-		await syncTools(ctx, ctx.model, { notifyWindowFailure: true });
-	});
-	pi.on("agent_start", () => invalidateCompaction());
-	pi.on("input", () => { invalidateCompaction(); });
-	pi.on("thinking_level_select", (event, ctx) => {
-		invalidateCompaction();
-		manualCompact.thinkingSelected(event.level, ctx);
-	});
+	pi.on("session_shutdown", invalidateCompaction);
+	pi.on("model_select", invalidateCompaction);
+	pi.on("before_agent_start", invalidateCompaction);
+	pi.on("agent_start", invalidateCompaction);
+	pi.on("input", invalidateCompaction);
+	pi.on("thinking_level_select", invalidateCompaction);
 	pi.on("message_start", invalidateCompaction);
-	pi.on("turn_end", (_event, ctx) => manualCompact.turnEnded(ctx));
-	pi.on("tool_call", (event) => {
-		invalidateCompaction();
-		return manualCompact.guardTool(event.toolName);
-	});
-	pi.on("session_before_switch", () => invalidateCompaction());
-	pi.on("session_before_fork", () => invalidateCompaction());
-	pi.on("session_before_tree", () => invalidateCompaction());
-	pi.on("session_tree", async (_event, ctx) => {
-		invalidateCompaction();
-		contextWindows.synchronize(ctx);
-		await manualCompact.recover(ctx);
-		await syncTools(ctx);
-	});
-	pi.on("before_provider_request", (event, ctx) => {
-		manualCompact.guardRequest(ctx);
-		return handleBeforeProviderRequest(event, ctx, dependencies.loadConfig, contextWindows, remoteContextActive, getContextToolRegistrationState);
-	});
+	pi.on("tool_call", invalidateCompaction);
+	pi.on("session_before_switch", invalidateCompaction);
+	pi.on("session_before_fork", invalidateCompaction);
+	pi.on("session_before_tree", invalidateCompaction);
+
+	// Exact gateway compatibility is shared transport policy, independent of
+	// compaction enablement. No window identities or ingest headers are generated.
 	pi.on("before_provider_headers", async (event, ctx) => {
-		const resolved = contextOperation(dependencies.loadConfig, ctx);
+		if (refuseRetiredSession(ctx, true)) return;
+		const resolved = contextOperation(loadConfig, ctx);
 		requireContextPolicy(resolved, ctx);
-		const config = resolved.config.compaction;
-		const contextModel = await resolveContextCapabilityModel(ctx);
-		if (!isCodexContextModel(contextModel, config)) return;
-		const active = await remoteContextActive(ctx, config, contextModel);
-		if (!active) {
-			const registrationState = getContextToolRegistrationState();
-			if (isExcludedGatewayContext(contextModel, config, registrationState)) return;
-			if (isCodexGatewayModel(contextModel, config.gatewayContextModels)) {
-				const reason = contextManagementFailureReason(registrationState);
-				notifyRemoteContextFailure(ctx, reason);
+		if (!resolved.gatewayModelKeys.length) return;
+		const resolution = await resolveNativeCompactionEnvironment(ctx, {
+			responsesApis: ["openai-responses"], codexGatewayModels: resolved.gatewayModelKeys,
+		});
+		if (refuseRetiredSession(ctx, true)) return;
+		if (!resolution.ok) {
+			const selected = isExactModelAllowed(ctx.model, resolved.gatewayModelKeys);
+			const physical = resolution.provider && resolution.model
+				? isExactModelAllowed({ provider: resolution.provider, id: resolution.model }, resolved.gatewayModelKeys) : false;
+			if (selected || physical) {
+				notifyWarning(ctx, "Configured gateway transport is unavailable; provider request aborted.");
 				ctx.abort();
 			}
 			return;
 		}
-		const provider = await resolveCodexContextProvider(ctx, ctx.model, config.gatewayContextModels);
-		if (provider.ok && provider.provider.kind === "codex-gateway") {
-			const sessionId = getSessionId(ctx);
-			const gatewayHeaders = codexContextProviderHeaders(provider.provider, {
-				sessionId,
-				clientRequestId: sessionId,
-			});
-			const allowedGatewayHeaders = new Set<string>(CODEX_GATEWAY_FORWARD_HEADERS);
+		const runtime = resolution.runtime;
+		if (!runtime.codexAffinity) return;
+		const gatewayHeaders = buildResponsesRequestHeaders(runtime, { accept: "text/event-stream" });
+		const allowed = new Set<string>(CODEX_GATEWAY_FORWARD_HEADERS);
+		for (const existing of Object.keys(event.headers)) {
+			if (!allowed.has(existing.toLowerCase())) delete event.headers[existing];
+		}
+		for (const name of ["authorization", "originator", "user-agent", "session-id", "x-client-request-id", "x-codex-affinity-scope", "x-codex-model"]) {
 			for (const existing of Object.keys(event.headers)) {
-				if (!allowedGatewayHeaders.has(existing.toLowerCase())) delete event.headers[existing];
-			}
-			// Keep any caller-supplied version without forcing a Toolkit pin.
-			// The gateway allowlist above already permits it.
-			for (const name of [
-				"authorization",
-				"originator",
-				"user-agent",
-				"session-id",
-				"x-client-request-id",
-				"x-codex-affinity-scope",
-				"x-codex-model",
-			]) {
-				for (const existing of Object.keys(event.headers)) {
-					if (existing.toLowerCase() === name) delete event.headers[existing];
-				}
-				const value = gatewayHeaders.get(name);
-				if (value) event.headers[name] = value;
+				if (existing.toLowerCase() === name) delete event.headers[existing];
 			}
+			const value = gatewayHeaders.get(name);
+			if (value) event.headers[name] = value;
 		}
-		contextWindows.rewriteHeaders(event.headers, ctx);
-	});
-	pi.on("message_end", async (event, ctx) => {
-		rememberPhysicalModel(ctx, event.message);
-		const resolved = contextOperation(dependencies.loadConfig, ctx);
-		requireContextPolicy(resolved, ctx);
-		const config = resolved.config.compaction;
-		const contextModel = await resolveContextCapabilityModel(ctx);
-		if (!isCodexContextModel(contextModel, config) || !tools.isRegistered) return undefined;
-		if (!(await remoteContextActive(ctx, config, contextModel))) return undefined;
-		const message = routeContextNamespaceToolMessage(event.message);
-		return message === event.message ? undefined : { message };
 	});
 }