pi-openai-toolkit 0.11.1 → 0.12.0

package/README.md

@@ -10,7 +10,7 @@
 
 ---
 
-`pi-openai-toolkit` is an all-in-one OpenAI enhancement package for **Pi (>= 0.84.x)**. It bundles five extensions designed for OpenAI Responses endpoints:
+`pi-openai-toolkit` is an all-in-one OpenAI enhancement package for **Pi (>= 0.85.1)**. It bundles five extensions designed for OpenAI Responses endpoints:
 
 1. **Remote Responses Compaction v2** (`extensions/compaction.ts`): Server-side opaque context compaction using the `remote_compaction_v2` SSE streaming protocol. Preserves context fidelity without lossy text re-summarization.
 2. **Model-Scoped Web Search** (`extensions/web-search.ts`): Toolkit-owned hosted Web Search for an exact `provider/model-id` allowlist configured with `webSearch.models`, across the supported `openai-responses` and `openai-codex-responses` APIs.
@@ -20,6 +20,8 @@
 
 ## Installation
 
+Requires **Pi >= 0.85.1** and **Node.js >= 22.19.0**; older Pi versions are not supported. Pi supplies the GPT-6 Astra catalog and OpenAI API Key/Codex subscription login; Toolkit does not implement a separate login flow.
+
 ### Install the published package globally (recommended)
 
 ```bash
@@ -104,11 +106,6 @@ C:\Users\<user>\.pi\agent\extensions\pi-openai-toolkit\config.json
       "model": null,
       "thinkingLevel": "off"
     },
-    "autoCompaction": {
-      "enabled": true,
-      "continuation": "inline",
-      "unsupportedFallback": "followUp"
-    },
     "responsesApis": [
       "openai-responses",
       "openai-codex-responses"
@@ -174,10 +171,6 @@ C:\Users\<user>\.pi\agent\extensions\pi-openai-toolkit\config.json
 - `nativeFallback.enabled` (*boolean*, default: `true`): Master switch for toolkit-driven native compaction with an explicit summary model. It never touches the remote chain: `remote_compaction_v2` is still attempted and still wins when it succeeds. When `false`, only the post-failure native step is skipped, so every fallback falls straight through to Pi's own default compaction with the active model.
 - `nativeFallback.model` (*string | null*, default: `null`): Summary model formatted as `provider/model-id` (e.g. `"openai/gpt-4o-mini"`) used **only** when the active model cannot use remote v2 at all (non-Responses API, or an API excluded by `responsesApis`). It is never consulted once a remote request was attempted, and `null` means the active model runs Pi's default compaction path.
 - `nativeFallback.thinkingLevel` (*string*, default: `"off"`): Reasoning / thinking level passed to Pi's native `compact()` whenever this extension supplies the model (`"off"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`).
-- `autoCompaction.enabled` (*boolean*, default: `true`): Check for compaction after a completed tool-result batch crosses Pi's context threshold.
-- `autoCompaction.continuation` (*`"inline" | "followUp" | "off"`*, default: `"inline"`): `inline` compacts inside the current official Pi 0.84.3 tool loop and refreshes the next provider context; `followUp` uses Pi's public hidden follow-up message path; `off` disables toolkit-triggered automatic compaction.
-- `autoCompaction.unsupportedFallback` (*`"followUp" | "off"`*, default: `"followUp"`): Behavior when the guarded official-host inline adapter is unavailable. It does not change normal remote/native compaction fallback ordering.
-- `autoCompaction.reserveTokens` (*non-negative integer*, optional): Override only the automatic trigger reserve. When omitted, the active Pi compaction setting is used. Pi's `keepRecentTokens` remains authoritative for compactability.
 - `responsesApis` (*string[]*): Narrow the supported remote compaction API identifiers (subset of `["openai-responses", "openai-codex-responses"]`).
 - `notifyOnLoad` (*boolean*, default: `false`): Show a notification banner on Pi startup.
 - `debug` (*boolean*, default: `false`): Output diagnostics and write execution artifacts to disk.
@@ -254,14 +247,15 @@ Content-Type: application/json
   2. Remote request attempted but failed on a model that *can* compact remotely &rarr; Pi's native `compact()` with `remoteCompactModel`, or the active model when no override is configured;
   3. Model that cannot use remote v2 at all &rarr; Pi's native `compact()` with `compaction.nativeFallback.model`, or the active model when unset;
 
-### 2. Tool-Loop Auto-Compaction and Continuation
+### 2. Pi-Native Auto-Compaction and Continuation
 
-After every complete tool-call/result batch, the toolkit checks the current Pi usage threshold. It then mirrors official Pi's `prepareCompaction()` eligibility using Pi's exported cut-point and session-entry helpers before invoking the normal `AgentSession.compact()` path.
+**Pi 0.85.1+** owns automatic compaction. After tool results are appended and before the next assistant request, Pi checks its threshold, compacts eligible history and continues in the same run. Toolkit only supplies Remote v2 results and opaque replay through public hooks: no private host patches, extra compaction driver or hidden follow-up messages.
 
-- **Inline mode**: On the guarded official Pi `0.84.3` host shape, compaction finishes before the next provider request and `prepareNextTurnWithContext` receives the newly built Pi session context. Remote v2, native fallback, replay rewriting, hook order, and deferred-tool carryover still run through their existing owners.
-- **Too-small sessions**: Crossing the token threshold does not prove there is discardable history. If Pi has nothing to summarize, the toolkit does not call `compact()`, does not abort the active run, and lets the unfinished tool loop continue normally.
-- **Public fallback**: `followUp` uses `ExtensionAPI.sendMessage` with a hidden `followUp` message after compaction. The turn is handled once, preventing repeated compaction/follow-up storms.
-- **Version guard**: The private same-loop adapter is enabled only for the structurally verified official Pi `0.84.3` `AgentSession`. Unsupported hosts use the configured public fallback or disable automatic continuation.
+- Configure `compaction.enabled`, `compaction.reserveTokens` and `compaction.keepRecentTokens` in Pi's `~/.pi/agent/settings.json` or project `.pi/settings.json`.
+- When Pi disables automatic compaction or has no eligible history, Toolkit does not start another driver. Manual `/compact` still uses the existing remote/native fallback chain.
+- The retired Toolkit `compaction.autoCompaction` setting is ignored as an unknown field; your settings file is not rewritten.
+- Remote v2 covers the complete compact input. A public `context` hook removes verified retained copies before encoding; persisted history is unchanged and new/transient messages survive.
+- Cache parameters follow Pi's actual selection: applicable GPT-5.6+ long-cache requests retain `prompt_cache_options.ttl: "30m"`, while those models retain `mode: "explicit"` when caching is disabled. Toolkit does not force long caching on every request, and a different compactor only receives supported cache fields.
 
 ### 3. Model-Scoped Web Search
 
@@ -314,7 +308,7 @@ GPT-6 Astra is a Codex-backend (ChatGPT OAuth) model with two wire behaviors tha
 - **Stable effort with `configuration_update`**: OpenAI prompt caching compares the request from the first byte, and the request-level `reasoning.effort` sits at the top - changing thinking level mid-conversation normally busts the whole cached prefix. Astra instead accepts a `configuration_update` input item that changes effort from that point onward while the request-level field stays put. This extension implements that for the active conversation: the first request pins the baseline effort, every later change is spliced into the transcript at the position it should take effect (before the user message it applies to, or after the latest tool result inside a tool loop), and the same item is replayed at that position on every following request. The request body keeps the baseline byte-stable, so the cache prefix survives level changes.
 - **History-rewrite safety**: Each spliced item is anchored to a fingerprint of the transcript position it was inserted at. If a later request's history no longer matches - compaction, branch switch, `/clear`, anything rewrote the transcript - the baseline is discarded and the next request re-pins its own effort, rather than placing an update at a stale position.
 - **Compaction isolation**: The compact endpoints reject histories containing `configuration_update` items. This is enforced in two places: the payload rewriter never splices items into a `compaction_trigger`-shaped request, and both compaction clients strip any such item defensively from replayed input, so an Astra session can still be compacted by this package.
-- **Scope**: The rewrite applies only to models listed in `codexAstra.models` on either Responses wire family (Astra is the only SKU known to accept the item; anything else answers HTTP 400 on it - the allowlist is what encodes that knowledge for gateways that proxy it), only when the request actually carries a wire-level effort, and never to `off`/`none`. Everything runs inside a try/catch: any unexpected payload shape or planner failure leaves the request untouched. To avoid double-splicing when both this toolkit and a host that implements the same behavior (Oh My Pi itself) are active, enable this layer on only one side.
+- **Scope**: The rewrite applies only to models listed in `codexAstra.models` on either Responses wire family (Astra is the only SKU known to accept the item; anything else answers HTTP 400 on it - the allowlist is what encodes that knowledge for gateways that proxy it), only when the request actually carries a wire-level effort, and never to `off`/`none`. Gateway pass-through was verified live: a `configuration_update` item placed before the user turn it applies to returned HTTP 200 with a completed response. Everything runs inside a try/catch: any unexpected payload shape or planner failure leaves the request untouched. To avoid double-splicing when both this toolkit and a host that implements the same behavior (Oh My Pi itself) are active, enable this layer on only one side.
 
 Catalog note: Pi's bundled `openai-codex` model list does not include `gpt-6-astra` yet. Register it in `~/.pi/agent/models.json` under the built-in provider (custom models merge into the built-in list): `api: "openai-codex-responses"`, `baseUrl: "https://chatgpt.com/backend-api"`, `contextWindow: 272000`, `maxTokens: 128000`, and a `thinkingLevelMap` exposing `low` through `max`. Pi's Codex OAuth login supplies the token; this package reads it through Pi's `ModelRegistry` and never touches the credential store directly.
 

package/README_zh.md

@@ -10,7 +10,7 @@
 
 ---
 
-`pi-openai-toolkit` 是专为 **Pi (>= 0.84.x)** 打造的 OpenAI 增强工具包，集成了五项针对 OpenAI Responses 协议的扩展：
+`pi-openai-toolkit` 是专为 **Pi (>= 0.85.1)** 打造的 OpenAI 增强工具包，集成了五项针对 OpenAI Responses 协议的扩展：
 
 1. **远端无损压缩 (Remote Compaction v2)** (`extensions/compaction.ts`): 基于 `remote_compaction_v2` SSE 流式协议实现的服务端密文无损会话压缩，彻底告别会话变长后丢失细节的文本二次摘要。
 2. **按模型启用的联网搜索** (`extensions/web-search.ts`): 通过 `webSearch.models` 精确匹配 `provider/model-id`，由 Toolkit 为符合条件的 `openai-responses` 与 `openai-codex-responses` 会话提供并拥有原生联网搜索。
@@ -20,6 +20,8 @@
 
 ## 安装使用
 
+需要 **Pi >= 0.85.1** 与 **Node.js >= 22.19.0**；不再支持旧 Pi。GPT-6 Astra 的模型目录、OpenAI API Key 和 Codex 订阅登录由 Pi 提供，Toolkit 不重复实现登录流程。
+
 ### 全局安装已发布版本（推荐）
 
 ```bash
@@ -102,11 +104,6 @@ C:\Users\<user>\.pi\agent\extensions\pi-openai-toolkit\config.json
       "model": null,
       "thinkingLevel": "off"
     },
-    "autoCompaction": {
-      "enabled": true,
-      "continuation": "inline",
-      "unsupportedFallback": "followUp"
-    },
     "responsesApis": [
       "openai-responses",
       "openai-codex-responses"
@@ -172,10 +169,6 @@ C:\Users\<user>\.pi\agent\extensions\pi-openai-toolkit\config.json
 - `nativeFallback.enabled` (*boolean*, 默认 `true`): Toolkit 用显式摘要模型跑原生压缩的总开关。它不影响远端链路：`remote_compaction_v2` 照常被尝试，成功时照常生效。设为 `false` 只跳过失败后的那一步原生压缩，因此所有降级都直接交给 Pi 默认的当前模型压缩。
 - `nativeFallback.model` (*string | null*, 默认 `null`): 摘要模型，格式为 `"provider/model-id"`（例如 `"openai/gpt-4o-mini"`），**仅**用于根本无法走远端 v2 的当前模型（非 Responses API，或 API 被 `responsesApis` 排除）。远端请求已经发出过的情境不会读这个字段；为 `null` 时由当前活动模型走 Pi 默认压缩路径。
 - `nativeFallback.thinkingLevel` (*string*, 默认 `"off"`): 由本扩展指定模型时，传给 Pi 原生 `compact()` 的思考级别。
-- `autoCompaction.enabled` (*boolean*, 默认 `true`): 完整工具调用/结果批次结束并越过 Pi 上下文阈值后，检查是否需要压缩。
-- `autoCompaction.continuation` (*`"inline" | "followUp" | "off"`*, 默认 `"inline"`): `inline` 在官方 Pi 0.84.3 当前工具循环内完成压缩并刷新下一次 Provider 上下文；`followUp` 使用 Pi 公共的隐藏后续消息；`off` 关闭 Toolkit 触发的自动压缩。
-- `autoCompaction.unsupportedFallback` (*`"followUp" | "off"`*, 默认 `"followUp"`): 官方 Host 私有 inline 适配器不可用时的处理方式，不改变原有远端/原生压缩降级顺序。
-- `autoCompaction.reserveTokens` (*非负整数*, 可选): 仅覆盖自动触发阈值的保留 Token 数。未设置时使用当前 Pi 压缩配置；是否具有可压缩历史仍以 Pi 的 `keepRecentTokens` 为准。
 - `responsesApis` (*string[]*): 允许尝试远端压缩的 API 标识符子集（从 `["openai-responses", "openai-codex-responses"]` 中选定）。
 - `notifyOnLoad` (*boolean*, 默认 `false`): Pi 启动加载时是否弹出气泡提示。
 - `debug` (*boolean*, 默认 `false`): 是否开启调试模式并记录诊断日志。
@@ -252,14 +245,15 @@ Content-Type: application/json
   2. 本可以远端压缩但网关报错或失败 &rarr; 用 `remoteCompactModel` 跑 Pi 原生 `compact()`，未配置覆盖模型则由当前活动模型执行；
   3. 根本无法走远端的模型 &rarr; 用 `compaction.nativeFallback.model` 跑 Pi 原生 `compact()`，未配置则由当前活动模型执行；
 
-### 2. 工具循环内自动压缩与续跑
+### 2. Pi 原生自动压缩与续跑
 
-每个完整工具调用/结果批次结束后，Toolkit 会检查当前 Pi 上下文阈值。真正调用压缩前，它使用 Pi 导出的 cut-point 与 session-entry helper 复现官方 `prepareCompaction()` 的可压缩性门禁，然后仍通过正常的 `AgentSession.compact()` 路径执行。
+自动压缩完全由 **Pi 0.85.1+** 管理。Pi 在工具结果写入后、下一次 assistant 请求前检查上下文阈值，符合条件时在同一次运行中压缩并继续。Toolkit 只通过公共 Hook 提供 Remote v2 结果和密文回放，不安装私有补丁、不额外触发压缩，也不发送隐藏续跑消息。
 
-- **Inline 模式**：仅在结构校验通过的官方 Pi `0.84.3` Host 上启用。压缩会在下一次 Provider 请求前完成，`prepareNextTurnWithContext` 使用 Pi 重建后的最新会话上下文。Remote v2、原生降级、密文重放、Hook 顺序和 deferred-tool carryover 仍由原有实现负责。
-- **历史过短**：越过 Token 阈值不代表一定存在可丢弃历史。若 Pi 没有可摘要内容，Toolkit 不调用 `compact()`、不终止当前运行，让未完成的工具循环正常继续。
-- **公共降级**：`followUp` 通过 `ExtensionAPI.sendMessage` 发送隐藏的后续消息，并对同一工具批次只处理一次，避免重复压缩或消息风暴。
-- **版本门禁**：私有同循环适配器仅支持结构验证通过的官方 Pi `0.84.3` `AgentSession`。其他 Host 按配置使用公共降级或关闭自动续跑。
+- 在 Pi 的 `~/.pi/agent/settings.json` 或项目 `.pi/settings.json` 中配置 `compaction.enabled`、`compaction.reserveTokens` 和 `compaction.keepRecentTokens`。
+- Pi 关闭自动压缩或没有可压缩历史时，Toolkit 不另开一套驱动；手动 `/compact` 仍使用原有远端/原生降级链路。
+- Toolkit 配置中的旧 `compaction.autoCompaction` 已移除；旧键会按未知字段忽略，不会修改你的配置文件。
+- Remote v2 已包含完整压缩输入。公共 `context` Hook 在编码前移除能确认已被 checkpoint 覆盖的近期消息副本；会话存档不变，压缩后的新消息和临时注入内容保留。
+- 缓存参数遵循 Pi 的实际选择：适用的 GPT-5.6+ 长缓存保留 `prompt_cache_options.ttl: "30m"`，这些模型关闭缓存时保留 `mode: "explicit"`，不会对所有请求强制开启长缓存。不同压缩模型只接收其支持的参数。
 
 ### 3. 按模型启用的联网搜索
 
@@ -312,7 +306,7 @@ GPT-6 Astra 是 Codex 后端（ChatGPT OAuth）上的模型，有两个普通 Op
 - **stable effort + `configuration_update`**：OpenAI 提示缓存从请求第一个字节开始比对，而请求级 `reasoning.effort` 就在头部——中途换思考档位通常会打爆整个缓存前缀。Astra 接受一种 `configuration_update` 输入项，从该项位置起改档位而不动请求级字段。本扩展把这套机制接到当前会话：首个请求钉住基线档位，之后的每次变更插入到它应生效的会话位置（作效于哪条用户消息就插在哪条之前，工具循环中途变更插在最近一条工具结果之后），后续请求在同一位置重放该项，请求体开头始终字节不变，缓存前缀存活。
 - **历史重写安全**：每个插入项都锚定在它所在位置前一条内容的指纹上。后续请求的历史对不上（压缩、切分支、`/clear`，任何历史重写），基线直接作废，下一次请求用自己的档位重新钉基线，而不是把更新插到过期位置。
 - **压缩隔离**：compact 端点拒绝含 `configuration_update` 的历史。两层防御：payload 改写器对带 `compaction_trigger` 的请求绝不插入；两个压缩客户端对回放输入里的该类项一律防御性剥离——所以 Astra 会话照常被本包压缩。
-- **适用范围**：改写只作用于两种 Responses 线协议家族内 `codexAstra.models` 白名单中的模型（目前已知只有 astra 接受该 item，其他模型碰它就 400——网关代理同一模型时，白名单就是声明这件事的地方），且只改真正携带线上级 effort 的请求，`off`/`none` 不动。整个钩子在 try/catch 里，任何意外形状或规划失败都原样放行请求。若 host 自身已实现同样行为（例如 Oh My Pi），两边只开一个，避免双重插入。
+- **适用范围**：改写只作用于两种 Responses 线协议家族内 `codexAstra.models` 白名单中的模型（目前已知只有 astra 接受该 item，其他模型碰它就 400——网关代理同一模型时，白名单就是声明这件事的地方），且只改真正携带线上级 effort 的请求，`off`/`none` 不动。网关透传已实测：插在生效用户消息之前的 `configuration_update` 返回 HTTP 200 且响应完整。整个钩子在 try/catch 里，任何意外形状或规划失败都原样放行请求。若 host 自身已实现同样行为（例如 Oh My Pi），两边只开一个，避免双重插入。
 
 目录说明：Pi 内置的 `openai-codex` 模型列表还没有 `gpt-6-astra`，需要在 `~/.pi/agent/models.json` 内置 provider 下注册（自定义 models 会与内置列表合并）：`api: "openai-codex-responses"`、`baseUrl: "https://chatgpt.com/backend-api"`、`contextWindow: 272000`、`maxTokens: 128000`，并用 `thinkingLevelMap` 声明 `low` 到 `max`。登录用 Pi 的 Codex OAuth 流程；本包通过 Pi 的 `ModelRegistry` 读凭据，不碰存储文件。
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "pi-openai-toolkit",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "description": "OpenAI-focused Pi toolkit providing remote Responses compaction, native Web Search, native image generation, and model-reviewed auto mode.",
   "author": "awoaCrim and contributors",
   "license": "MIT",
@@ -48,7 +51,6 @@
     "src/debug.ts",
     "src/details-store.ts",
     "src/deferred-tool-carryover.ts",
-    "src/inline-compaction.ts",
     "src/extension-runtime.ts",
     "src/image-generation/artifacts.ts",
     "src/image-generation/client.ts",
@@ -97,16 +99,16 @@
     "typecheck": "tsc -p tsconfig.check.json"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "*",
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": ">=0.80.0",
-    "@earendil-works/pi-tui": ">=0.80.0"
+    "@earendil-works/pi-agent-core": ">=0.85.1",
+    "@earendil-works/pi-ai": ">=0.85.1",
+    "@earendil-works/pi-coding-agent": ">=0.85.1",
+    "@earendil-works/pi-tui": ">=0.85.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.84.3",
-    "@earendil-works/pi-ai": "0.84.3",
-    "@earendil-works/pi-coding-agent": "0.84.3",
-    "@earendil-works/pi-tui": "0.84.3",
+    "@earendil-works/pi-agent-core": "0.85.1",
+    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-tui": "0.85.1",
     "@types/node": "24.12.4",
     "bun": "1.2.23",
     "typescript": "5.9.3"

package/src/config.ts

@@ -5,7 +5,6 @@ import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import {
 	DEFAULT_COMPACTION_CONFIG,
 	DEFAULT_TOOLKIT_CONFIG,
-	DEFAULT_AUTO_COMPACTION_CONFIG,
 	DEFAULT_AUTO_MODE_CONFIG,
 	DEFAULT_IMAGE_GENERATION_CONFIG,
 	DEFAULT_CODEX_ASTRA_CONFIG,
@@ -47,7 +46,6 @@ const COMPACTION_FIELDS = new Set([
 	"allowCompactionContinuityBreak",
 	"remoteCompactModel",
 	"nativeFallback",
-	"autoCompaction",
 	"responsesApis",
 	"notifyOnLoad",
 	"debug",
@@ -57,7 +55,6 @@ const COMPACTION_FIELDS = new Set([
 	"artifactRoot",
 ]);
 const NATIVE_FALLBACK_FIELDS = new Set(["enabled", "model", "thinkingLevel"]);
-const AUTO_COMPACTION_FIELDS = new Set(["enabled", "continuation", "unsupportedFallback", "reserveTokens"]);
 const WEB_SEARCH_FIELDS = new Set(["enabled", "models"]);
 const IMAGE_GENERATION_FIELDS = new Set(["enabled"]);
 const CODEX_ASTRA_FIELDS = new Set(["enabled", "models"]);
@@ -153,37 +150,6 @@ function toThinkingLevel(value: unknown, fieldPath: string, warnings: string[]):
 	return undefined;
 }
 
-function toCompactionContinuation(
-	value: unknown,
-	fieldPath: string,
-	warnings: string[],
-): "inline" | "followUp" | "off" | undefined {
-	if (value === undefined) return undefined;
-	if (value === "inline" || value === "followUp" || value === "off") return value;
-	warnings.push(`Ignoring ${fieldPath}: expected one of inline, followUp, off.`);
-	return undefined;
-}
-
-function toUnsupportedFallback(
-	value: unknown,
-	fieldPath: string,
-	warnings: string[],
-): "followUp" | "off" | undefined {
-	if (value === undefined) return undefined;
-	if (value === "followUp" || value === "off") return value;
-	warnings.push(`Ignoring ${fieldPath}: expected one of followUp, off.`);
-	return undefined;
-}
-
-function toNonNegativeInteger(value: unknown, fieldPath: string, warnings: string[]): number | undefined {
-	if (value === undefined) return undefined;
-	if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value >= 0) {
-		return value;
-	}
-	warnings.push(`Ignoring ${fieldPath}: expected a non-negative integer.`);
-	return undefined;
-}
-
 function toBoundedInteger(
 	value: unknown,
 	fieldPath: string,
@@ -264,7 +230,6 @@ function cloneDefaults(): ToolkitConfig {
 		compaction: {
 			...DEFAULT_COMPACTION_CONFIG,
 			nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
-			autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 			responsesApis: [...DEFAULT_COMPACTION_CONFIG.responsesApis],
 		},
 		webSearch: {
@@ -305,32 +270,6 @@ function applyNativeFallbackConfig(
 		resolved.thinkingLevel;
 }
 
-function applyAutoCompactionConfig(
-	raw: Record<string, unknown>,
-	resolved: CompactionConfig["autoCompaction"],
-	warnings: string[],
-): void {
-	warnUnknownFields(raw, AUTO_COMPACTION_FIELDS, "compaction.autoCompaction", warnings);
-	resolved.enabled = toBoolean(raw.enabled, "compaction.autoCompaction.enabled", warnings) ?? resolved.enabled;
-	resolved.continuation =
-		toCompactionContinuation(raw.continuation, "compaction.autoCompaction.continuation", warnings) ??
-		resolved.continuation;
-	resolved.unsupportedFallback =
-		toUnsupportedFallback(
-			raw.unsupportedFallback,
-			"compaction.autoCompaction.unsupportedFallback",
-			warnings,
-		) ?? resolved.unsupportedFallback;
-	const reserveTokens = toNonNegativeInteger(
-		raw.reserveTokens,
-		"compaction.autoCompaction.reserveTokens",
-		warnings,
-	);
-	if (reserveTokens !== undefined) {
-		resolved.reserveTokens = reserveTokens;
-	}
-}
-
 function applyCompactionConfig(
 	raw: Record<string, unknown>,
 	resolved: CompactionConfig,
@@ -375,14 +314,6 @@ function applyCompactionConfig(
 		}
 	}
 
-	if (raw.autoCompaction !== undefined) {
-		if (isRecord(raw.autoCompaction)) {
-			applyAutoCompactionConfig(raw.autoCompaction, resolved.autoCompaction, warnings);
-		} else {
-			warnings.push("Ignoring compaction.autoCompaction: expected a JSON object.");
-		}
-	}
-
 	const apis = toSupportedApis(
 		raw.responsesApis,
 		"compaction.responsesApis",

package/src/extension-runtime.ts

@@ -1,5 +1,6 @@
 import type {
 	BeforeProviderRequestEvent,
+	ContextEvent,
 	CompactionResult,
 	ExtensionAPI,
 	ExtensionContext,
@@ -11,11 +12,11 @@ import { resolveLatestNativeCompactionEntry } from "./details-store";
 import { runNativeFallbackCompaction } from "./native-fallback";
 import {
 	rewriteResponsesPayloadWithNativeReplay,
+	removeNativeCompactionRetainedMessages,
 	serializeLiveTailToResponsesInput,
 } from "./payload-rewrite";
 import { getCompactionRequestExtras, rememberRequestContext } from "./request-context-cache";
 import { executeRemoteV2Compaction } from "./remote-v2-client";
-import { registerInlineCompactionRuntime } from "./inline-compaction";
 import {
 	resolveNativeCompactionEnvironment,
 	resolveRemoteCompactionExecution,
@@ -33,6 +34,12 @@ import {
 	type NativeCompactionRequestMeta,
 } from "./types";
 
+type CompactionDependencies = {
+	loadConfig: typeof loadToolkitConfig;
+	remoteCompact: typeof executeRemoteV2Compaction;
+	nativeFallback: typeof runNativeFallbackCompaction;
+};
+
 type ResponsesCompactOutcome =
 	| { outcome: "success"; compaction: CompactionResult<NativeCompactionDetails> }
 	| { outcome: "aborted" }
@@ -98,6 +105,7 @@ async function runResponsesNativeCompact(
 	ctx: ExtensionContext,
 	config: CompactionConfig,
 	execution: RemoteCompactionExecution,
+	remoteCompact: typeof executeRemoteV2Compaction,
 ): Promise<ResponsesCompactOutcome> {
 	const { consumer, compactor } = execution;
 	const instructions = buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions);
@@ -179,12 +187,12 @@ async function runResponsesNativeCompact(
 		model: consumer.model,
 		baseUrl: consumer.baseUrl,
 		sessionId: getSessionId(ctx),
-	});
+	}, compactor.currentModel);
 	if (extras) {
 		request = { ...request, ...extras };
 	}
 
-	const compactResult = await executeRemoteV2Compaction({
+	const compactResult = await remoteCompact({
 		runtime: compactor,
 		request,
 		signal: event.signal,
@@ -287,8 +295,12 @@ async function runResponsesNativeCompact(
 	return { outcome: "success", compaction };
 }
 
-async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx: ExtensionContext) {
-	const { config: toolkitConfig } = loadToolkitConfig();
+async function handleSessionBeforeCompact(
+	event: SessionBeforeCompactEvent,
+	ctx: ExtensionContext,
+	dependencies: CompactionDependencies,
+) {
+	const { config: toolkitConfig } = dependencies.loadConfig();
 	const config = toolkitConfig.compaction;
 	if (!config.enabled) {
 		return undefined;
@@ -327,7 +339,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 	);
 	if (resolution.ok) {
 		remoteAttempted = true;
-		const responsesOutcome = await runResponsesNativeCompact(event, ctx, config, resolution.execution);
+		const responsesOutcome = await runResponsesNativeCompact(event, ctx, config, resolution.execution, dependencies.remoteCompact);
 		if (responsesOutcome.outcome === "success") {
 			return { compaction: responsesOutcome.compaction };
 		}
@@ -362,7 +374,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 	// 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;
-	const fallback = await runNativeFallbackCompaction({ ctx, event, config, modelSpec: fallbackModelSpec });
+	const fallback = await dependencies.nativeFallback({ ctx, event, config, modelSpec: fallbackModelSpec });
 	if (fallback.ok) {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
@@ -414,8 +426,35 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 	return undefined;
 }
 
-async function handleBeforeProviderRequest(event: BeforeProviderRequestEvent, ctx: ExtensionContext) {
-	const { config: toolkitConfig } = loadToolkitConfig();
+async function handleContext(event: ContextEvent, ctx: ExtensionContext, loadConfig: typeof loadToolkitConfig) {
+	const { config: { compaction: config } } = loadConfig();
+	if (!config.enabled) return undefined;
+	// Resolve the effective authenticated endpoint before dropping any history.
+	// A checkpoint for a different endpoint must keep Pi's original context.
+	const resolution = await resolveNativeCompactionEnvironment(ctx, {
+		enabled: config.enabled,
+		responsesApis: config.responsesApis,
+	});
+	if (!resolution.ok) return undefined;
+	const branchEntries = ctx.sessionManager.getBranch();
+	const latest = resolveLatestNativeCompactionEntry(branchEntries, { baseUrl: resolution.runtime.baseUrl });
+	if (!latest.ok) return undefined;
+	const result = removeNativeCompactionRetainedMessages({ messages: event.messages, branchEntries, compactionEntry: latest.entry });
+	if (!result.ok) {
+		writeReplayFailureArtifact({ reason: result.reason, compactionEntryId: latest.entry.id }, config, ctx);
+		if (ctx.hasUI) ctx.ui.notify(`${COMPACTION_EXTENSION_ID}: replay failed (${result.reason}); request aborted`, "error");
+		ctx.abort();
+		return undefined;
+	}
+	return result.messages === event.messages ? undefined : { messages: result.messages };
+}
+
+async function handleBeforeProviderRequest(
+	event: BeforeProviderRequestEvent,
+	ctx: ExtensionContext,
+	loadConfig: typeof loadToolkitConfig,
+) {
+	const { config: toolkitConfig } = loadConfig();
 	const config = toolkitConfig.compaction;
 	if (!config.enabled) {
 		return undefined;
@@ -570,11 +609,18 @@ async function handleBeforeProviderRequest(event: BeforeProviderRequestEvent, ct
 	return rewrite.rewrittenPayload;
 }
 
-export default function (pi: ExtensionAPI) {
-	const inlineCompaction = registerInlineCompactionRuntime(pi, loadToolkitConfig);
-
+export default function registerCompactionExtension(
+	pi: ExtensionAPI,
+	overrides: Partial<CompactionDependencies> = {},
+) {
+	const dependencies: CompactionDependencies = {
+		loadConfig: loadToolkitConfig,
+		remoteCompact: executeRemoteV2Compaction,
+		nativeFallback: runNativeFallbackCompaction,
+		...overrides,
+	};
 	pi.on("session_start", (_event, ctx) => {
-		const { config: toolkitConfig, source, warnings } = loadToolkitConfig();
+		const { config: toolkitConfig, source, warnings } = dependencies.loadConfig();
 		const config = toolkitConfig.compaction;
 		if (!config.enabled) return;
 
@@ -604,8 +650,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.on("session_before_compact", handleSessionBeforeCompact);
-	pi.on("before_provider_request", handleBeforeProviderRequest);
-	pi.on("turn_end", (event, ctx) => inlineCompaction.handlePublicTurnEnd(event, ctx));
-	pi.on("session_shutdown", (_event, ctx) => inlineCompaction.dispose(ctx));
+	pi.on("context", (event, ctx) => handleContext(event, ctx, dependencies.loadConfig));
+	pi.on("session_before_compact", (event, ctx) => handleSessionBeforeCompact(event, ctx, dependencies));
+	pi.on("before_provider_request", (event, ctx) => handleBeforeProviderRequest(event, ctx, dependencies.loadConfig));
 }

package/src/payload-rewrite.ts

@@ -1,3 +1,4 @@
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type {
@@ -33,7 +34,8 @@ export type NativeReplayPayloadRewriteFailureReason =
 	| "first-kept-entry-not-found"
 	| "invalid-compacted-window"
 	| "unexpected-compaction-after-boundary"
-	| "compaction-summary-not-found";
+	| "compaction-summary-not-found"
+	| "retained-context-mismatch";
 
 export type NativeReplayPayloadRewriteFailure = {
 	ok: false;
@@ -311,6 +313,41 @@ export function collectLiveTailMessages(entries: readonly SessionEntry[]): Agent
 	return collectReplayMessages(entries);
 }
 
+/**
+ * Remote V2 covers the complete pre-compaction context. Pi 0.85.1 also retains
+ * recent messages, so remove those verified copies before provider conversion
+ * (where IDs/fields may change across models). Persisted session entries are
+ * untouched. Preserve transient additions and all post-compaction messages.
+ */
+export function removeNativeCompactionRetainedMessages(args: {
+	messages: AgentMessage[];
+	branchEntries: readonly SessionEntry[];
+	compactionEntry: NativeCompactionEntry;
+}): { ok: true; messages: AgentMessage[] } | NativeReplayPayloadRewriteFailure {
+	const boundary = findCompactionBoundaryIndex(args.branchEntries, args.compactionEntry.id);
+	if (boundary === undefined) return { ok: false, reason: "compaction-boundary-not-found" };
+	const firstKept = findEntryIndexByIdBeforeBoundary(args.branchEntries, args.compactionEntry.firstKeptEntryId, boundary);
+	if (firstKept === undefined) return { ok: false, reason: "first-kept-entry-not-found" };
+	const summary = sessionEntryToContextMessages(args.compactionEntry)[0];
+	const summaryIndex = args.messages.findIndex((message) => areEquivalentValues(message, summary));
+	if (summaryIndex < 0) return { ok: false, reason: "compaction-summary-not-found" };
+	const retained = args.branchEntries.slice(firstKept, boundary).flatMap(sessionEntryToContextMessages);
+	const removed = new Set<number>();
+	let cursor = summaryIndex + 1;
+	for (const expected of retained) {
+		const index = args.messages.findIndex((message, index) => index >= cursor && areEquivalentValues(message, expected));
+		if (index >= 0) {
+			removed.add(index);
+			cursor = index + 1;
+		}
+	}
+	// Already removed by another context handler: leave it alone. Partial
+	// matches are ambiguous; never remove half a call/result batch.
+	if (removed.size === 0) return { ok: true, messages: args.messages };
+	if (removed.size !== retained.length) return { ok: false, reason: "retained-context-mismatch" };
+	return { ok: true, messages: args.messages.filter((_, index) => !removed.has(index)) };
+}
+
 export function serializeLiveTailToResponsesInput<TApi extends Api>(args: {
 	model: Model<TApi>;
 	entries: readonly SessionEntry[];
@@ -370,15 +407,8 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		};
 	}
 
-	const preCompactionEntries = args.branchEntries.slice(firstKeptEntryIndex, boundaryIndex);
-	const postCompactionEntries = args.branchEntries.slice(boundaryIndex + 1);
-
-	// Pi-authored compaction summary item. Pi 0.84.3 renders the context after a
-	// compaction as [leading prompts][summary item][all post-compaction messages]:
-	// pre-compaction messages never appear in the payload (entry.retainedTail is
-	// never persisted by appendCompaction), so the summary item itself is the only
-	// anchor and the only thing that gets replaced. Everything else is preserved
-	// verbatim, so transient messages injected by other extensions stay intact.
+	// The context hook has removed Pi's verified retained copies. Replace only
+	// the summary anchor here; preserve provider fields and transient/post items.
 	const summaryIndex = findCompactionSummaryIndex(args.payload.input, args.compactionEntry.summary);
 	if (summaryIndex < 0) {
 		return {