pi-openai-toolkit 0.20.4 → 0.20.6

package/README.md

@@ -54,9 +54,9 @@ Set `defaults.context.mode` or an individual model's `context.mode`:
 
 **Remote windows** require the native `openai-codex` provider with `openai-codex-responses`, or an `openai-responses` gateway implementing the protocol. Gateways require `compatibility.transport: "codex-gateway"` on the exact model entry. This setting does not add the capability to an ordinary compatible endpoint.
 
-Change `mode` in the example above to `remote-windows`. Eligible sessions expose `new_context`, `get_context_remaining`, `history`, and `notes`. Manual `/compact [instructions]` starts a checkpoint handoff: write notes successfully, then switch windows. Models without window capability retain the compaction flow; a failed window activation does not silently switch to a summary.
+Change `mode` in the example above to `remote-windows`. Eligible sessions expose `new_context`, `get_context_remaining`, `history`, and `notes`. Manual `/compact [instructions]` starts a checkpoint handoff: write notes successfully, then switch windows. Models without window capability use only the current local window projection: retired Remote Context history is not sent to the model or to a configured compaction producer. A no-summary local boundary preserves the persisted Remote Window / Context Session, so switching back to a supported model reuses the same window instead of opening a duplicate one. The legacy `leaveManagedMode` setting is retained for config compatibility but no longer triggers bulk close-out compaction.
 
-Remote windows use alpha endpoints that may change upstream. When switching models, also watch for retired-window history that has not yet been trimmed. See the [window lifecycle](docs/internals.md#rollover-lifecycle).
+Remote windows use alpha endpoints that may change upstream. When switching models, the remote window remains persisted and reusable; see the [window lifecycle](docs/internals.md#rollover-lifecycle).
 
 ## Search, images, and tool review
 

package/README.zh.md

@@ -54,9 +54,9 @@ Toolkit 只读取一个全局配置文件，即使扩展安装在项目内也一
 
 **远程窗口**需要原生 `openai-codex` 提供商的 `openai-codex-responses` API，或支持相应协议的 `openai-responses` 网关。网关必须在精确模型下设置 `compatibility.transport: "codex-gateway"`；这一设置不会让普通兼容端点自动获得该能力。
 
-将上例的 `mode` 改为 `remote-windows` 后，符合条件的会话会提供 `new_context`、`get_context_remaining`、`history` 和 `notes`。手动 `/compact [instructions]` 会发起检查点交接：先成功写入 notes，再切换窗口。不具备窗口能力的模型仍走压缩流程；窗口激活失败不会静默改用摘要。
+将上例的 `mode` 改为 `remote-windows` 后，符合条件的会话会提供 `new_context`、`get_context_remaining`、`history` 和 `notes`。手动 `/compact [instructions]` 会发起检查点交接：先成功写入 notes，再切换窗口。不具备窗口能力的模型只使用当前本地窗口投影：已经由 Remote Context 托管的旧窗口历史不会发送给该模型，也不会发送给配置的 compaction 模型。扩展会用一个不生成摘要的本地边界保留已持久化的 Remote Window / Context Session；切回支持窗口的模型时会复用同一个窗口，不会重复创建。旧配置中的 `leaveManagedMode` 仍会解析，但不再触发批量 close-out 压缩。
 
-远程窗口依赖 alpha 接口，上游可能随时调整。切换模型前也要留意旧窗口历史仍未清理的情况，详见[窗口生命周期](docs/internals.md#rollover-lifecycle)。
+远程窗口依赖 alpha 接口，上游可能随时调整。切换模型时远程窗口状态仍会持久化并可复用，详见[窗口生命周期](docs/internals.md#rollover-lifecycle)。
 
 ## 搜索、生图与工具审查
 

package/docs/configuration.md

@@ -65,10 +65,10 @@ Place `context` under `defaults` or an exact `models` entry.
 | `nativeFallback.enabled` | `true` | Enable the existing native-method fallback tier. |
 | `nativeFallback.model` | `null` | Optional summary-model reference on the remote-ineligible path. After a remote attempt fails, the existing producer-first fallback order is retained. |
 | `nativeFallback.thinkingLevel` | `"off"` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`; actual model support still applies. |
-| `remoteWindows.leaveManagedMode` | `"warn"` | `"compact"` also requests a close-out when retired history exceeds 80% of the next model's window and compaction can finish. Print mode remains warning-only; turn-end close-out requires a queued trim. |
+| `remoteWindows.leaveManagedMode` | `"warn"` | Legacy compatibility field. Both values preserve the same behavior: non-window models receive only the current local window, and no bulk close-out compaction is started for retired Remote Context history. |
 | `remoteWindows.reminderThresholdPercent` | `5` | Integer 0-100. `0` disables both the once-per-window reminder and exhausted-window fallback. |
 
-Native Codex eligibility derives from the actual Pi provider/API. Gateways additionally need the exact transport opt-in below. `remote-windows` retains the compaction chain for models outside window capability. A configured window model whose activation fails does not silently receive a summary fallback. Normal `new_context` keeps its persisted-notes, duplicate and cooldown gates. Synthetic Remote V2 producer/consumer identity and checkpoint provenance are unchanged. See [Toolkit internals](internals.md).
+Native Codex eligibility derives from the actual Pi provider/API. Gateways additionally need the exact transport opt-in below. `remote-windows` keeps the Remote Window state persisted when a model without window capability is selected: that model receives only the current local window, while retired/managed Remote Context history is excluded from live requests and compaction producers. A no-summary boundary preserves the marker for later reuse. A configured window model whose activation fails does not silently receive a summary fallback. Normal `new_context` keeps its persisted-notes, duplicate and cooldown gates. Synthetic Remote V2 producer/consumer identity and checkpoint provenance are unchanged. See [Toolkit internals](internals.md).
 
 In active `remote-windows`, `/compact [instructions]` starts checkpoint duty rather than producing a summary. The selected model must authenticate to the same native backend/account or gateway credential/affinity domain, fit the projected window plus its output reserve, and retain the required permitted context tools. Invalid or unsuitable explicit targets are refused without switching to a fallback model. If Auto Mode is engaged, the target must also be eligible for its gate. The entire handoff uses the initiating context-policy snapshot; no config or global Pi defaults are rewritten.
 

package/docs/internals.md

@@ -94,9 +94,9 @@ State invariants the lifecycle code must keep honest:
 - Budget checks are skipped until the current window has produced its own assistant usage. Acting on the previous window's usage anchor would burn the once-per-window reminder on a false alarm.
 - Preparing a boundary never consumes its scheduled trim. The manager reconciles the latest persisted compaction and branch state, so only a durable matching boundary consumes it. Missing/late callbacks, aborted preparation and navigation across branches sharing a marker remain retryable. Automatic threshold/overflow and toolkit-owned manual maintenance only trim a matching scheduled window; a user manual `/compact` follows the managed handoff below.
 - A window boundary is persisted as a `codex-context-window` custom message. `session_start` replays boundaries from the branch and rebuilds identity after forks.
-- Retiring windows is a projection-level act: the session branch keeps every retired window until a compaction consumes the scheduled trim. `evaluateWindowBulk()` measures that gap and compares it with the model about to receive it, `decideBulkCliffAction()` maps the report onto the `leaveManagedMode` policy (`warn` default, `compact`), and `decideBulkCloseOut()` only allows the automatic compaction where a compaction can actually finish: never in print mode (the process exits with the turn and would kill the summary), and at turn end only while a rollover trim is queued, because the window policy cancels every other compaction. Each window and model is surfaced once, and every decision writes a `window-bulk.<action>` compaction artifact with its trigger.
-- The close-out runs from `model_select` and `agent_settled`, never from `before_agent_start`: `ExtensionContext.compact()` aborts the running turn, and a hook inside turn processing is exactly the busy lane it must not fight.
-- A configured native-fallback summary model is checked against the size of the request Pi is about to send it (`estimateSummarizationRequest`). A narrower summary model than the active one - 272k summarizing a 400k session - returns `model-window-too-small` before authentication or the model call, so the current model gets the first attempt instead of a terminated stream.
+- Retiring windows remains a projection-level operation in the persisted branch, but a non-window consumer never receives that retired history. `context_with_system` trims to the latest persisted Remote Context boundary, preserves the current system/tool head, and removes the internal window marker before the local provider request. The legacy `leaveManagedMode` setting is retained only so old config files remain valid; it no longer warns or starts a bulk close-out from `model_select` or `agent_settled`.
+- If a non-window consumer reaches `session_before_compact` while a Remote Context boundary exists, the extension returns a no-summary compaction anchored at that boundary. No Remote V2/native compaction producer receives the Remote window, Pi retains the marker and current-window tail, and switching back to a supported model reuses the persisted window identity. A session with no Remote boundary keeps the ordinary compaction path.
+- The configured native-fallback summary model is still checked against the physical request size (`estimateSummarizationRequest`). The guard remains a provider-safety invariant; the Remote-window fix avoids the oversized request by excluding managed history before any compaction producer can be called, rather than removing the guard or chunking the request.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openai-toolkit",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "private": false,
   "type": "module",
   "engines": {

package/src/context-management/window-bulk.ts

@@ -8,6 +8,12 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { LeaveManagedModePolicy } from "../types";
 import { isContextWindowBoundary } from "./messages";
 
+/**
+ * Legacy pure diagnostics retained for config/test compatibility. Runtime model switching no
+ * longer calls this module: non-window consumers use the current-local projection instead of
+ * measuring or compacting the durable Remote Context branch.
+ */
+
 /**
  * Share of the target model's context window above which a projection is considered
  * over budget. Estimates are conservative (`estimateTokens` is chars/4 and overestimates),

package/src/context-management/window-manager.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { ProviderHeaders } from "@earendil-works/pi-ai";
 import {
+	buildSessionContext,
 	calculateContextTokens,
 	estimateTokens,
 	type CompactionResult,
@@ -11,7 +12,6 @@ import {
 	type SessionEntry,
 } from "@earendil-works/pi-coding-agent";
 import { ContextWindowBudget, type ContextRemaining } from "./window-budget";
-import type { WindowBulkReport } from "./window-bulk";
 import {
 	rewriteEncryptedToolOutputs,
 	rewriteWindowHeaders,
@@ -86,8 +86,6 @@ export class CodexContextWindowManager {
 	private trimPendingWindowId: string | undefined;
 	private readonly projectionDiagnostics = new Set<string>();
 	private lastKnownSystemHead: AgentMessage | undefined;
-	private bulkReport: WindowBulkReport | undefined;
-	private bulkSurfacedKey: string | undefined;
 	/**
 	 * Pi's getContextUsage() measures the durable transcript. Remote windows are
 	 * projected only by this extension, so remember the last provider-visible
@@ -105,50 +103,16 @@ export class CodexContextWindowManager {
 		this.pendingRollover = undefined;
 		this.projectionDiagnostics.clear();
 		this.lastKnownSystemHead = undefined;
-		this.bulkReport = undefined;
-		this.bulkSurfacedKey = undefined;
 	}
 
 	currentIdentity(): ContextWindowIdentity | undefined {
 		return this.identity ? { ...this.identity } : undefined;
 	}
-	/**
-	 * Whether a rollover trim is queued for the next eligible compaction. A turn-end bulk
-	 * close-out is only worth a model call while that trim is still outstanding.
-	 */
+	/** Whether a rollover trim awaits a matching persisted compaction. */
 	hasPendingTrim(): boolean {
 		return this.trimPendingWindowId !== undefined;
 	}
 
-	/** Remember the latest measurement for this window; see `takeBulkCliff`. */
-	noteWindowBulk(report: WindowBulkReport | undefined, modelKey: string): void {
-		if (report) this.bulkReport = report;
-		else if (this.bulkKey(modelKey) === undefined) this.bulkReport = undefined;
-	}
-
-	/**
-	 * Drain the pending bulk-cliff notice for this window and model. The decision what to
-	 * do about it (warn, or compact before the next request) belongs to the runtime; this
-	 * only guarantees the same window and model is never surfaced twice.
-	 */
-	takeBulkCliff(modelKey: string): WindowBulkReport | undefined {
-		const report = this.bulkReport;
-		if (!report || !report.expanded) return undefined;
-		const key = this.bulkKey(modelKey);
-		if (key === undefined || this.bulkSurfacedKey === key) return undefined;
-		this.bulkSurfacedKey = key;
-		return report;
-	}
-
-	private bulkKey(modelKey: string): string | undefined {
-		// The report's own window id is authoritative: this notice exists precisely for the
-		// models that never open the window lifecycle, where `identity` stays undefined.
-		const windowId = this.bulkReport?.windowId ?? this.identity?.currentWindowId;
-		return windowId ? `${windowId}|${modelKey}` : undefined;
-	}
-
-
-
 	private resetWindowState(): void {
 		this.identity = undefined;
 		this.sessionId = undefined;
@@ -246,7 +210,7 @@ export class CodexContextWindowManager {
 
 	project(
 		messages: readonly AgentMessage[],
-		mode: "off" | "remote",
+		mode: "off" | "local" | "remote",
 	): AgentMessage[] {
 		if (mode === "off") {
 			this.projectedContextTokens = undefined;
@@ -268,20 +232,30 @@ export class CodexContextWindowManager {
 				if (!matchesSession(message.details.sessionId, this.sessionId)) continue;
 			}
 			if (!isContextWindowBoundary(message)) continue;
+			// Local consumers follow the synchronized persisted identity, not a
+			// queued marker from the request view. They never own the Remote session.
+			if (mode === "local" && message.details.contextManagement.currentWindowId !== this.identity?.currentWindowId) continue;
 			boundaryIndex = index;
-			this.identity = identityFromDetails(message.details);
+			if (mode === "remote") this.identity = identityFromDetails(message.details);
 		}
 		if (boundaryIndex < 0) {
-			this.identity = undefined;
-			this.restoredMarkerId = undefined;
-			this.budget.reset();
-			this.trimPendingWindowId = undefined;
+			if (mode === "local" && this.identity) {
+				throw new Error("Persisted Codex context-window boundary missing from local projection");
+			}
+			if (mode === "remote") {
+				this.identity = undefined;
+				this.restoredMarkerId = undefined;
+				this.budget.reset();
+				this.trimPendingWindowId = undefined;
+			}
 			this.projectedContextTokens = undefined;
 		}
 		// Projection observes the request view, never durable session state. A
 		// queued rollover marker must not clear the duplicate guard here.
-		const trimmed = boundaryIndex < 0 ? [...messages] : this.trimToWindow(messages, boundaryIndex);
-		const projected = mode === "remote" ? projectEncryptedToolResults(trimmed) : trimmed;
+		const trimmed = boundaryIndex < 0 ? [...messages] : this.trimToWindow(messages, boundaryIndex, mode === "local");
+		const projected = mode === "remote" ? projectEncryptedToolResults(trimmed) : trimmed.filter(
+			(message) => message.role !== "custom" || message.customType !== CODEX_CONTEXT_WINDOW_MESSAGE_TYPE,
+		);
 		this.projectedContextTokens = mode === "remote" && this.identity
 			? estimateProjectedWindowTokens(projected)
 			: undefined;
@@ -295,10 +269,13 @@ export class CodexContextWindowManager {
 	 * sent, because a window without tools silently degrades into a chat the model can
 	 * only narrate. Each refusal is reported once per window and reason.
 	 */
-	private trimToWindow(messages: readonly AgentMessage[], boundaryIndex: number): AgentMessage[] {
+	private trimToWindow(messages: readonly AgentMessage[], boundaryIndex: number, local = false): AgentMessage[] {
 		const repair = preserveSystemHead({ messages, boundaryIndex, fallbackHead: this.lastKnownSystemHead });
 		if (repair.head) this.lastKnownSystemHead = repair.head;
 		if (repair.shrinkRejected) {
+			// Remote requests retain the existing tool-preservation fallback. A
+			// local request must never recover tools by leaking retired windows.
+			if (local) throw new Error("Cannot preserve the system/tool head in local context-window projection");
 			this.recordProjectionDiagnostic(repair.lostToolNames);
 		}
 		return [...repair.messages];
@@ -461,6 +438,33 @@ export class CodexContextWindowManager {
 		return { compaction };
 	}
 
+	/**
+	 * Detach a local consumer at the durable Remote boundary, without summarizing
+	 * any Remote-managed history. Unlike a scheduled rollover trim, this needs
+	 * no pending trim and remains retryable until Pi persists the result.
+	 */
+	prepareDetachedCompaction(
+		event: SessionBeforeCompactEvent,
+	): { compaction: CompactionResult<ContextWindowCompactionDetails> } | undefined {
+		const boundary = findLatestWindowBoundaryEntry(event.branchEntries, this.sessionId);
+		if (!boundary) return undefined;
+		const compaction = this.createCompaction(event);
+		// Pi's preparation/tokensBefore describes the durable branch, which includes
+		// Remote-managed history. Detached local accounting must use the same current
+		// window projection that the non-window provider sees instead.
+		return {
+			compaction: {
+				...compaction,
+				tokensBefore: this.estimateLocalContextTokens(event.branchEntries),
+			},
+		};
+	}
+
+	private estimateLocalContextTokens(entries: readonly SessionEntry[]): number {
+		const messages = buildSessionContext(entries as never[]).messages as unknown as AgentMessage[];
+		return this.project(messages, "local").reduce((total, message) => total + estimateTokens(message as never), 0);
+	}
+
 	recordCompaction(details: unknown): void {
 		if (!isContextWindowCompactionDetails(details)) return;
 		if (this.trimPendingWindowId !== undefined && details.windowId === this.trimPendingWindowId) {

package/src/extension-runtime.ts

@@ -20,12 +20,6 @@ import { routeContextNamespaceToolMessage } from "./context-management/namespace
 import { loadHistoryNotesThreadHint } from "./context-management/history-notes";
 import { CodexContextWindowManager } from "./context-management/window-manager";
 import { ManagedManualCompact } from "./context-management/manual-compact";
-import {
-	BULK_CLIFF_RATIO,
-	decideBulkCliffAction,
-	decideBulkCloseOut,
-	evaluateWindowBulk,
-} from "./context-management/window-bulk";
 import {
 	registerContextManagementTools,
 	type ContextToolRegistrationState,
@@ -752,14 +746,22 @@ async function handleSessionBeforeCompact(
 		return { cancel: true };
 	}
 
-	// Remote Context management owns this eligible Codex session. It persists a
-	// no-summary boundary while active; an unavailable runtime uses the configured
-	// Remote V2 compactor instead of silently returning to Pi's active-model path.
+	// Capability changes do not retire the persisted Remote session. Resolve its
+	// branch boundary before deciding whether any compactor may see this input.
+	if (config.contextManagement === "remote") {
+		try {
+			dependencies.contextWindows.synchronize(ctx);
+		} catch {
+			notifyRemoteContextFailure(ctx, "malformed-window-state");
+			return { cancel: true };
+		}
+	}
+
+	// Active and inactive covered Codex consumers retain their existing routing.
 	const contextModel = await resolveContextCapabilityModel(ctx);
 	if (isCodexContextModel(contextModel, config)) {
 		if (await remoteContextActive(ctx, config, contextModel)) {
 			try {
-				dependencies.contextWindows.synchronize(ctx);
 				if (event.reason === "manual" && dependencies.manualCompact && !dependencies.manualCompact.isMaintenance) {
 					await dependencies.manualCompact.request(event, ctx, resolved);
 					return { cancel: true };
@@ -786,6 +788,18 @@ async function handleSessionBeforeCompact(
 		);
 	}
 
+	if (config.contextManagement === "remote") {
+		try {
+			const detached = dependencies.contextWindows.prepareDetachedCompaction(event);
+			// A local consumer cannot summarize history owned by a Remote window,
+			// even through a configured Luna producer or Pi's default compactor.
+			if (detached) return detached;
+		} catch {
+			notifyRemoteContextFailure(ctx, "malformed-window-state");
+			return { cancel: true };
+		}
+	}
+
 	// Resolve producer protocol policy from this operation's document, not a later disk read.
 	if (resolved.format === "v2" && config.remoteCompactModel) {
 		const producer = parseModelSpec(config.remoteCompactModel);
@@ -868,7 +882,9 @@ async function handleSessionBeforeCompact(
 			config,
 			ctx,
 		);
-		if (config.remoteCompactModel) {
+		const expectedConsumerCapabilityMiss =
+			resolution.reason === "unsupported-api" && resolution.modelSpec === undefined;
+		if (config.remoteCompactModel && !expectedConsumerCapabilityMiss) {
 			notifyWarning(
 				ctx,
 				`remote compaction model "${config.remoteCompactModel}" unusable (${resolution.reason}); using the native fallback chain`,
@@ -941,81 +957,6 @@ async function handleSessionBeforeCompact(
 	return undefined;
 }
 
-/**
- * Surface (and optionally close) the gap between the durable transcript and the remote window.
- *
- * Remote context management retires previous windows in the request projection, so a covered
- * model never notices that the branch still carries every one of them. Switching to a model
- * without remote context - or resuming such a session - hands that whole pile to the provider
- * at once, and the first manual `/compact` then has to summarize it. Runs once per agent turn,
- * never per request, and only once per window and model so the notice cannot become a nag.
- */
-async function handleWindowBulk(
-	ctx: ExtensionContext,
-	contextWindows: CodexContextWindowManager,
-	loadConfig: typeof loadToolkitConfig,
-	trigger: "model-switch" | "turn-end",
-	resolved = contextOperation(loadConfig, ctx),
-	beginMaintenance?: () => () => void,
-): Promise<void> {
-	requireContextPolicy(resolved, ctx);
-	const compaction = resolved.config.compaction;
-	if (!compaction.enabled || compaction.contextManagement !== "remote") return;
-	if (!ctx.model) return;
-
-	const modelKey = `${ctx.model.provider}/${ctx.model.id}`;
-	const report = evaluateWindowBulk(ctx);
-	if (!report) return;
-	contextWindows.noteWindowBulk(report, modelKey);
-	const cliff = contextWindows.takeBulkCliff(modelKey);
-	if (!cliff) return;
-	const action = decideBulkCloseOut({
-		action: decideBulkCliffAction(cliff, compaction.leaveManagedMode),
-		mode: ctx.mode,
-		trigger,
-		hasPendingTrim: contextWindows.hasPendingTrim(),
-	});
-	if (action === "ignore") return;
-
-	writeDebugArtifact(
-		"compaction-event",
-		{
-			event: `window-bulk.${action}`,
-			trigger,
-			policy: compaction.leaveManagedMode,
-			model: modelKey,
-			unmanagedTokens: cliff.unmanagedTokens,
-			managedTokens: cliff.managedTokens,
-			targetContextWindow: cliff.targetContextWindow,
-			overBudget: cliff.overBudget,
-		},
-		compaction,
-		ctx,
-	);
-
-	const gap = `${cliff.unmanagedTokens.toLocaleString()} tokens of retired windows are still in this session's transcript, while remote context management has been sending ${cliff.managedTokens.toLocaleString()}`;
-	if (action === "warn") {
-		notifyWarning(
-			ctx,
-			`${gap} to ${modelKey}${cliff.overBudget ? `, past ${Math.round(BULK_CLIFF_RATIO * 100)}% of its window` : ""}. Checkpoint with notes and run /compact (or new_context) before continuing on a model without remote context, or set compaction.leaveManagedMode="compact" to do it automatically.`,
-		);
-		return;
-	}
-
-	notifyWarning(ctx, `${gap} to ${modelKey}, past ${Math.round(BULK_CLIFF_RATIO * 100)}% of its window; compacting the retired windows first.`);
-	if (typeof ctx.compact !== "function") return;
-	const done = beginMaintenance?.();
-	try {
-		ctx.compact({
-			onComplete: () => done?.(),
-			onError: (error: Error) => {
-				done?.();
-				notifyWarning(ctx, `automatic boundary compaction failed: ${error.message}`);
-			},
-		});
-	} catch (error) { done?.(); throw error; }
-}
-
 async function handleContextInternal(
 	event: ContextWithSystemEvent,
 	ctx: ExtensionContext,
@@ -1035,6 +976,7 @@ async function handleContextInternal(
 			: { messages: visibleMessages };
 	}
 
+	let localMessages: AgentMessage[] | undefined;
 	if (config.contextManagement === "remote") {
 		const contextModel = await resolveContextCapabilityModel(ctx);
 		try {
@@ -1095,22 +1037,40 @@ async function handleContextInternal(
 				? undefined
 				: { messages: visibleMessages };
 		}
+
+		try {
+			const projected = contextWindows.project(event.messages, "local");
+			localMessages = projected;
+			if (contextWindows.currentIdentity()) {
+				// This boundary owns earlier history, including any older Remote V2
+				// checkpoint. A local request must not replay that history back in.
+				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;
+		}
 	}
 
-	// Inactive/ineligible Remote mode must not expose internal window markers to a
-	// gateway or another provider. The existing compaction replay path remains the
-	// owner for this safe fallback.
-	const visibleMessages = contextWindows.project(event.messages, "off");
+	// With no Remote boundary, the ordinary checkpoint replay path remains the
+	// owner. Inactive covered Codex consumers were handled separately above.
+	const visibleMessages = localMessages ?? contextWindows.project(event.messages, "off");
+	const visibleResult = visibleMessages.length === event.messages.length && visibleMessages.every((message, index) => message === event.messages[index])
+		? undefined : { messages: visibleMessages };
 	const replayEvent = visibleMessages === event.messages ? event : { ...event, messages: visibleMessages };
 	const resolution = await resolveNativeCompactionEnvironment(ctx, {
 		enabled: config.enabled,
 		responsesApis: config.responsesApis,
 		codexGatewayModels: compactGatewayModels(resolved),
 	});
-	if (!resolution.ok) return undefined;
+	if (!resolution.ok) return visibleResult;
 	const branchEntries = ctx.sessionManager.getBranch();
 	const latest = resolveLatestNativeCompactionEntry(branchEntries, { baseUrl: resolution.runtime.baseUrl });
-	if (!latest.ok) return undefined;
+	if (!latest.ok) return visibleResult;
 	const result = removeNativeCompactionRetainedMessages({
 		messages: replayEvent.messages,
 		branchEntries,
@@ -1124,7 +1084,7 @@ async function handleContextInternal(
 		ctx.abort();
 		return undefined;
 	}
-	return result.messages === replayEvent.messages ? undefined : { messages: result.messages };
+	return result.messages === replayEvent.messages ? visibleResult : { messages: result.messages };
 }
 
 /**
@@ -1203,6 +1163,10 @@ async function handleBeforeProviderRequest(
 		return undefined;
 	}
 
+	// Do not reintroduce a pre-window opaque checkpoint after local projection.
+	// Request affinity/encrypted-output rewriting is reserved for active Remote.
+	if (config.contextManagement === "remote" && contextWindows.currentIdentity()) return undefined;
+
 	const resolution = await resolveNativeCompactionEnvironment(
 		ctx,
 		{
@@ -1518,10 +1482,9 @@ export default function registerCompactionExtension(
 		tools.reset();
 	});
 	pi.on("agent_settled", async (_event, ctx) => {
-		// Idle: no retry, compaction, or queued continuation is left running, so this is the
-		// only safe place to spend a model call on the user's behalf.
-		if (await manualCompact.settled(ctx)) return;
-		await handleWindowBulk(ctx, contextWindows, dependencies.loadConfig, "turn-end", undefined, () => manualCompact.beginMaintenance());
+		// 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) => {
 		manualCompact.modelSelected(event.model, ctx);
@@ -1532,9 +1495,6 @@ export default function registerCompactionExtension(
 		// 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);
-		// The switch itself is the moment the durable transcript changes consumer, and the
-		// session is idle here, so the close-out must happen now rather than mid-turn.
-		if (!manualCompact.busy) await handleWindowBulk(ctx, contextWindows, dependencies.loadConfig, "model-switch", resolved, () => manualCompact.beginMaintenance());
 	});
 	pi.on("before_agent_start", async (_event, ctx) => {
 		await syncTools(ctx, ctx.model, { notifyWindowFailure: true });

package/src/native-fallback.ts

@@ -1,7 +1,8 @@
 import {
 	compact,
+	convertToLlm,
 	DEFAULT_COMPACTION_SETTINGS,
-	estimateTokens,
+	serializeConversation,
 	type CompactionResult,
 	type ExtensionContext,
 	type SessionBeforeCompactEvent,
@@ -59,16 +60,10 @@ function toErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
-/**
- * Output budget Pi gives the summary itself: `generateSummary` caps `maxTokens` at
- * `min(floor(0.8 * reserveTokens), model.maxTokens)`.
- */
-const SUMMARIZATION_OUTPUT_RESERVE_TOKENS = Math.floor(
-	DEFAULT_COMPACTION_SETTINGS.reserveTokens * 0.8,
-);
-
-/** Summarization instructions plus the `<conversation>` framing around the transcript. */
+/** Summarization instructions plus the framing around the serialized transcript. */
 const SUMMARIZATION_TEMPLATE_TOKENS = 1024;
+const HISTORY_OUTPUT_RESERVE_RATIO = 0.8;
+const TURN_PREFIX_OUTPUT_RESERVE_RATIO = 0.5;
 
 export type SummarizationRequestSize = {
 	inputTokens: number;
@@ -76,33 +71,93 @@ export type SummarizationRequestSize = {
 	totalTokens: number;
 };
 
+function estimateTextTokens(text: string | undefined): number {
+	return text ? Math.ceil(String(text).length / 4) : 0;
+}
+
+function estimateSerializedConversationTokens(
+	messages: SessionBeforeCompactEvent["preparation"]["messagesToSummarize"],
+): number {
+	const serialized = serializeConversation(convertToLlm(messages));
+	return estimateTextTokens(serialized);
+}
+
+function getEffectiveReserveTokens(preparation: SessionBeforeCompactEvent["preparation"]): number {
+	const reserveTokens = preparation.settings?.reserveTokens;
+	return typeof reserveTokens === "number" && Number.isFinite(reserveTokens) && reserveTokens >= 0
+		? reserveTokens
+		: DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+}
+
+function getOutputReserveTokens(
+	reserveTokens: number,
+	model: { maxTokens?: number },
+	ratio: number,
+): number {
+	const outputTokens = Math.floor(ratio * reserveTokens);
+	return typeof model.maxTokens === "number" && model.maxTokens > 0
+		? Math.min(outputTokens, model.maxTokens)
+		: outputTokens;
+}
+
+function estimateSummaryRequest(
+	messages: SessionBeforeCompactEvent["preparation"]["messagesToSummarize"],
+	outputTokens: number,
+	previousSummary?: string,
+	customInstructions?: string,
+): SummarizationRequestSize {
+	const inputTokens =
+		SUMMARIZATION_TEMPLATE_TOKENS
+		+ estimateSerializedConversationTokens(messages)
+		+ estimateTextTokens(previousSummary)
+		+ estimateTextTokens(customInstructions);
+	return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+}
+
 /**
- * Size of the request Pi's `compact()` is about to send, measured the same way Pi
- * measures context (the exported `estimateTokens`, a conservative chars/4).
+ * Size of the individual request(s) Pi's `compact()` is about to send.
  *
- * A session driven by a wide-window model (400k) produces a preparation that a narrower
- * summary model (272k) cannot accept at all: the provider terminates the stream and the
- * first manual `/compact` fails. Callers must not attempt that request; the estimate is
- * deliberately an under-declaration of certainty, so a missing `contextWindow` skips the
- * check instead of guessing.
+ * Pi first converts messages with `convertToLlm()` and then applies
+ * `serializeConversation()`, which truncates tool results before they enter the
+ * summarization prompt. Split-turn compaction sends history and turn-prefix
+ * summaries as separate requests, so this returns the largest individual request
+ * rather than adding their inputs together. The fixed allowance remains
+ * deliberately conservative for Pi's system prompt, tags, and instructions.
+ *
+ * A session driven by a wide-window model (400k) can produce a preparation that a
+ * narrower summary model (272k) cannot accept. Callers must not attempt that request;
+ * a missing `contextWindow` skips the check instead of guessing.
  */
 export function estimateSummarizationRequest(
 	preparation: SessionBeforeCompactEvent["preparation"],
 	model: { contextWindow?: number; maxTokens?: number },
+	customInstructions?: string,
 ): SummarizationRequestSize {
-	const conversation = [
-		...(preparation.messagesToSummarize ?? []),
-		...(preparation.turnPrefixMessages ?? []),
-	];
-	let inputTokens = SUMMARIZATION_TEMPLATE_TOKENS;
-	for (const message of conversation) inputTokens += estimateTokens(message as never);
-	if (preparation.previousSummary) {
-		inputTokens += Math.ceil(String(preparation.previousSummary).length / 4);
+	const reserveTokens = getEffectiveReserveTokens(preparation);
+	const historyMessages = preparation.messagesToSummarize ?? [];
+	const turnPrefixMessages = preparation.turnPrefixMessages ?? [];
+	const historyOutputTokens = getOutputReserveTokens(reserveTokens, model, HISTORY_OUTPUT_RESERVE_RATIO);
+	const historyRequest = estimateSummaryRequest(
+		historyMessages,
+		historyOutputTokens,
+		preparation.previousSummary,
+		customInstructions,
+	);
+
+	if (!preparation.isSplitTurn || turnPrefixMessages.length === 0) {
+		return historyRequest;
 	}
-	const outputTokens = model.maxTokens && model.maxTokens > 0
-		? Math.min(SUMMARIZATION_OUTPUT_RESERVE_TOKENS, model.maxTokens)
-		: SUMMARIZATION_OUTPUT_RESERVE_TOKENS;
-	return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+
+	const requests = [
+		...(historyMessages.length > 0 ? [historyRequest] : []),
+		estimateSummaryRequest(
+			turnPrefixMessages,
+			getOutputReserveTokens(reserveTokens, model, TURN_PREFIX_OUTPUT_RESERVE_RATIO),
+		),
+	];
+	return requests.reduce((largest, request) =>
+		request.totalTokens > largest.totalTokens ? request : largest,
+	);
 }
 
 /** Whether the summary model can accept this request at all; unknown windows always pass. */
@@ -163,7 +218,11 @@ export async function runNativeFallbackCompaction(args: {
 		return { ok: false, reason: "same-as-current-model", modelSpec: spec };
 	}
 
-	const size = estimateSummarizationRequest(event.preparation, model as { contextWindow?: number; maxTokens?: number });
+	const size = estimateSummarizationRequest(
+		event.preparation,
+		model as { contextWindow?: number; maxTokens?: number },
+		event.customInstructions,
+	);
 	if (!fitsSummarizationRequest(size, model as { contextWindow?: number })) {
 		return {
 			ok: false,

package/src/types.ts

@@ -79,7 +79,10 @@ export type NativeFallbackConfig = {
 	thinkingLevel: ThinkingLevel;
 };
 
-/** How the toolkit reacts when leaving remote context management would re-expand the transcript. */
+/**
+ * Legacy compatibility setting. Remote Context history is no longer bulk-compacted when
+ * selecting a non-window model; local projection and a no-summary boundary own that handoff.
+ */
 export type LeaveManagedModePolicy = "warn" | "compact";
 
 export type DebugConfig = {
@@ -94,8 +97,8 @@ export type DebugConfig = {
 export type CompactionConfig = {
 	enabled: boolean;
 	/**
-	 * What to do when the session is about to hand a model the whole durable transcript
-	 * instead of its remote window: warn, or compact the retired windows away first.
+	 * Legacy compatibility setting. Non-window consumers never receive retired Remote Context
+	 * history, regardless of this value; retained config files continue to parse it.
 	 */
 	leaveManagedMode: LeaveManagedModePolicy;
 	/** Optional Codex Remote Context management. Disabled by default for compatibility. */