@narumitw/pi-codex-compact 0.51.3 → 0.53.0

package/README.md

@@ -2,21 +2,20 @@
 
 [![npm](https://img.shields.io/npm/v/@narumitw/pi-codex-compact)](https://www.npmjs.com/package/@narumitw/pi-codex-compact) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 
-Use Codex Remote Compaction V2 in Pi instead of generating a local plaintext summary for models that use the `openai-codex-responses` API.
-
-The extension requests and stores an opaque server-generated checkpoint, then safely replays it in later Codex Responses requests.
-
-Pi still decides when compaction runs and retains its normal `/compact`, threshold, overflow, and session-publication behavior.
+Use Responses compaction in Pi through Remote Compaction V2 or the unary `responses/compact` API.
+The extension stores an opaque server-generated checkpoint and replays it in later compatible requests instead of generating a local plaintext summary.
+Pi still decides when compaction runs and keeps its normal `/compact`, threshold, overflow, and session-publication behavior.
 
 ## ✨ Features
 
-- Uses the active Codex Responses provider and credentials without persisting secrets or request headers.
+- Supports `openai-codex-responses`, `openai-responses`, and `azure-openai-responses`, plus explicitly profiled custom APIs.
+- Uses Remote V2 or same-origin unary `responses/compact` through the active provider and credentials.
 - Handles manual, threshold, and overflow compaction through Pi's existing lifecycle.
 - Validates and persists one bounded opaque checkpoint that survives compatible reloads, resumes, and forks.
 - Replays the latest checkpoint while preserving newer conversation and extension context.
-- Supports repeated compaction by carrying the previous checkpoint into the next request.
+- Supports repeated and cross-protocol compaction by carrying the previous checkpoint forward.
 - Falls back to Pi's native plaintext compaction on non-cancellation failures.
-- Provides `/codex-compact` for route status, settings, and manual compaction.
+- Provides `/codex-compact` for effective-route status, settings, and manual compaction.
 
 ## 📦 Install
 
@@ -39,42 +38,35 @@ npm --workspace @narumitw/pi-codex-compact run build
 pi -e ./packages/pi-codex-compact
 ```
 
-The package declares `dist/index.ts`, so an unbuilt local checkout must be built before Pi loads the package directory.
-Loading the package enables Remote V2 with safe defaults.
-Avoid loading a global npm installation and the local workspace at the same time.
+The package declares `dist/index.ts`, so build a local checkout before loading its package directory.
+Loading the package enables automatic Responses compaction routing with the documented defaults.
+Do not load a global npm installation and the local workspace at the same time.
+
+Pi extensions run with your user permissions.
+Review third-party extension source before installing it.
 
 ## 🚀 Quick start
 
-1. Sign in through Pi's built-in OpenAI Codex provider, or configure a custom provider that routes to a compatible Codex backend.
-2. Select a model whose API is `openai-codex-responses`.
-3. Work normally.
-   Pi's automatic compaction and built-in `/compact` continue to operate.
-4. Run `/codex-compact` to inspect the effective route or choose **Compact now**.
-5. After compaction, continue the session normally; compatible requests replay the opaque checkpoint.
+1. Sign in through Pi's built-in OpenAI, OpenAI Codex, or Azure OpenAI provider, or configure a compatible custom provider.
+2. Select a model using `openai-codex-responses`, `openai-responses`, or `azure-openai-responses`.
+3. Work normally; Pi's automatic compaction and built-in `/compact` continue to operate.
+
+Run `/codex-compact` when you want to inspect the effective route or choose **Compact now**.
+After compaction, compatible requests replay the opaque checkpoint automatically.
 
+With the default `auto` protocol, Codex Responses uses Remote V2 while OpenAI and Azure OpenAI Responses use unary `responses/compact`.
 When the active model uses another API, compaction remains entirely Pi-native.
+To opt in a compatible custom API, add it to `apiProfiles` as described below.
 
 ## 💬 Commands
 
-```text
-/codex-compact
-```
-
-In TUI mode, the root menu shows whether Remote V2 is enabled, the active model, and whether a manual compact will use **Codex Remote V2** or **Pi native**.
-It contains:
+Run `/codex-compact` to inspect the effective compaction path, change settings, or request manual compaction in TUI mode.
+It accepts no arguments.
+RPC reports the manual settings path without compacting; print and JSON modes reject the command.
+Closing the menu with Escape or Ctrl+C does not compact the session.
 
-```text
-Compact now
-Settings
-Close
-```
-
-**Compact now** closes the menu before asking Pi to compact the active session.
-Escape or Ctrl+C closes without compacting, and an obsolete menu cannot trigger work after session replacement or shutdown.
-**Settings** opens the bounded settings editor.
-In non-TUI modes, the command reports the manual settings path instead of opening custom UI or compacting.
-
-Pi's built-in `/compact` remains available and follows the same extension hook when the active model uses `openai-codex-responses`.
+Manual compaction uses **Responses Remote V2**, **Responses Compact API**, or **Pi native**, as described in [Settings](#-settings).
+Pi's built-in `/compact` remains available and follows the same extension hook.
 
 ## ⚙️ Settings
 
@@ -90,6 +82,10 @@ There is no environment-variable or project-level override.
 ```json
 {
   "enabled": true,
+  "protocol": "auto",
+  "apiProfiles": {
+    "custom-responses": "codex-responses-v1"
+  },
   "requestTimeoutMs": 300000,
   "maxRetries": 2,
   "replacementTokenBudget": 64000,
@@ -99,19 +95,21 @@ There is no environment-variable or project-level override.
 
 | Setting | Default | Accepted values | Behavior | Recommendation |
 | --- | ---: | --- | --- | --- |
-| `enabled` | `true` | Boolean | Attempt Remote V2 when the active model uses `openai-codex-responses`. | Keep enabled unless diagnosing provider behavior. |
+| `enabled` | `true` | Boolean | Attempt a supported remote compaction route. | Keep enabled unless diagnosing provider behavior. |
+| `protocol` | `"auto"` | `"auto"`, `"remote-v2"`, or `"responses-compact"` | Select by API or force one remote protocol. | Keep `auto`; force a route only when diagnosing a compatible backend. |
+| `apiProfiles` | `{}` | Object mapping a custom API id to `"codex-responses-v1"` | Explicitly opts a non-built-in API into Codex-compatible request fields and replay. | Leave empty unless the provider documents Codex Responses compatibility. |
 | `requestTimeoutMs` | `300000` | Integer from 30,000 to 600,000 ms | Bound one extension-owned remote request. | Keep five minutes; increase only for a consistently slow connection. |
 | `maxRetries` | `2` | Integer from 0 to 2 | Retry transient provider transport failures before Pi fallback. | Keep two; use zero when diagnosing the first failure. |
 | `replacementTokenBudget` | `64000` | Integer from 8,000 to 128,000 tokens | Bound approximate retained user-message text beside the opaque item. | Keep 64K; lower it to reduce session size or raise it only when recent user context is being lost. |
-| `notifyOnFallback` | `true` | Boolean | Warn when Remote V2 fails and Pi-native compaction takes over. | Keep enabled so silent fallback does not hide protocol or entitlement problems. |
+| `notifyOnFallback` | `true` | Boolean | Warn when remote compaction fails and Pi-native compaction takes over. | Keep enabled so silent fallback does not hide protocol or entitlement problems. |
 
 Missing fields use defaults.
 Settings reload on every `session_start`, including `/reload`, resume, and fork.
 Menu writes apply immediately, preserve unknown JSON fields, serialize within the current Pi process, and use a final conflict check plus same-directory atomic rename.
 On Unix, temporary files use mode `0600`.
 
-Malformed, invalid, oversized, or symlinked settings files are never overwritten.
-Safe defaults stay active, and the menu provides read-only repair guidance until the file is fixed and Pi is reloaded.
+Malformed, invalid, oversized, or symlinked settings files remain unchanged.
+Defaults stay active, and the menu remains read-only until the file is fixed and Pi is reloaded.
 Separate Pi processes do not share a mutation lock; a detected concurrent edit is rejected so the user can reopen Settings and retry.
 
 ### Relationship to Codex configuration
@@ -120,49 +118,59 @@ This extension does **not** read `~/.codex/config.toml`.
 
 | Codex setting | Extension behavior |
 | --- | --- |
-| `features.remote_compaction_v2` | Conceptually corresponds to this extension's `enabled`; it is not imported. |
+| `features.remote_compaction_v2` | Conceptually corresponds to `protocol: "remote-v2"`; it is not imported. |
 | `model_auto_compact_token_limit` | Not duplicated. Pi's own compaction threshold remains authoritative. |
 | `model_auto_compact_token_limit_scope` | Not supported; Pi extensions do not own Codex's compact-window lineage. |
-| `compact_prompt` / `experimental_compact_prompt_file` | Not used by Remote V2, whose opaque checkpoint is generated by the server. |
+| `compact_prompt` / `experimental_compact_prompt_file` | Not used by either remote protocol, whose opaque checkpoint is generated by the server. |
 | `features.token_budget` | Not supported; token-budget context reset is a different experimental strategy. |
 
 ## ✅ Requirements and compatibility
 
 - Pi APIs compatible with the package's declared peer dependencies.
-- API `openai-codex-responses` on the active model.
-- A built-in or custom provider that routes that API to a backend supporting `compaction_trigger` and opaque `compaction` replay.
-- Working credentials and Remote V2 entitlement for that backend.
-
-The built-in `openai-codex` provider is supported, and a custom provider or proxy is eligible when its model explicitly uses `openai-codex-responses`.
-Generic `openai-responses`, `azure-openai-responses`, GitHub Copilot, and other merely Responses-compatible API labels are not eligible.
-The extension does not probe provider capabilities before compaction; a provider that declares `openai-codex-responses` owns compatible routing, authentication, request transforms, SSE transport, and opaque replay.
-A failed Remote V2 compaction attempt falls back to Pi native, but an ordinary request cannot transparently recover after an incompatible provider has already received an existing opaque checkpoint.
+- One of `openai-codex-responses`, `openai-responses`, or `azure-openai-responses` on the active model, or an explicit `apiProfiles` entry for a custom Codex-compatible API.
+- A provider whose HTTP Responses adapter honors Pi's public `onPayload` and injected `fetch` options.
+- A backend supporting the selected protocol and opaque `compaction` replay.
+- Working credentials and any required compaction entitlement.
+
+| Model API | `auto` route | Other selectable route |
+| --- | --- | --- |
+| `openai-codex-responses` | Responses Remote V2 | Responses Compact API |
+| `openai-responses` | Responses Compact API | Responses Remote V2 |
+| `azure-openai-responses` | Responses Compact API | Responses Remote V2 |
+
+The installed built-in adapters are covered by deterministic transport tests.
+A custom provider or proxy is eligible when its model explicitly uses one of these APIs, but its backend still owns compatible routing, authentication, request transforms, and opaque replay.
+For a custom API label, eligibility is opt-in: `apiProfiles` must map that exact non-built-in label to `"codex-responses-v1"`. The default is empty, and an unconfigured custom API remains Pi-native.
+`codex-responses-v1` uses Remote V2 in `auto` mode. With `responses-compact` explicitly selected, it retains the Codex Compact request fields, including tools and reasoning. The provider must honor Pi's public `transport: "sse"`, `onPayload`, and injected `fetch` options, and its backend must support the selected compaction protocol and opaque item replay. The profile declares compatibility; it does not probe the backend.
+The extension does not send a separate capability probe or automatically retry a failed billable request through the other protocol.
+A failed remote attempt falls back to Pi native, but an ordinary request cannot transparently recover after an incompatible provider has already received an existing opaque checkpoint.
 Provider provenance is stored for diagnosis but is not a replay gate.
-Switching providers can replay a checkpoint only when the API and exact model ID still match; switching model IDs leaves Pi's visible fallback marker plus retained recent messages in context.
+Switching providers can replay a checkpoint only when the API label, compatibility profile, and exact model ID still match. Custom API checkpoints also require a current matching `apiProfiles` entry; removing or changing it leaves Pi's visible fallback marker plus retained recent messages in context.
 
 ## 🔄 How it works
 
 1. Pi prepares compaction and selects the recent message suffix it will retain.
 2. If an earlier compatible checkpoint is present, the extension identifies its boundary from the summary persisted on the active `CompactionEntry` and validates the retained suffix fingerprints.
-3. It projects that checkpoint into the current Responses input, appends exactly one final `compaction_trigger`, and sends a normal authenticated Codex Responses SSE request with cache retention disabled.
-4. It requires a completed response containing exactly one non-empty opaque `compaction` item.
-5. It constructs bounded replacement history from recent raw user-role Responses items followed by the opaque item.
-6. It stores that history and fingerprints of Pi's retained suffix in versioned `CompactionEntry.details`.
+3. Remote V2 projects that checkpoint into a normal Responses SSE request and appends exactly one final `compaction_trigger`.
+4. Unary compact captures the provider-built payload and authentication, rewrites only the same-origin `/responses` path to `/responses/compact`, and requests JSON without making a normal inference call.
+5. It requires one bounded non-empty opaque `compaction` item; unary output may precede it only with user-role retained messages.
+6. It constructs bounded replacement history and stores it with Pi suffix fingerprints, the real API label, and the resolved compatibility profile in versioned `CompactionEntry.details`.
 7. On later compatible requests, it replaces an exactly validated marker with the persisted replacement history immediately before provider dispatch.
 
 The persisted entry remains the summary identity source, so replay does not depend on the wording generated by the currently installed extension version.
 If persisted summary identity, fingerprints, model identity, payload shape, or marker count do not match exactly, the extension leaves Pi's visible fallback context unchanged instead of guessing.
+Older v1 and v2 checkpoints are normalized to the current checkpoint format when read; their built-in API label determines the profile. They still replay only when the current route authorizes that API/profile/model combination.
 
 ## 🔒 Security and privacy
 
-Remote compaction sends the active conversation context, system prompt, and active tool schemas to the configured backend used by the selected Codex Responses provider.
+Remote compaction sends the active conversation context and system prompt to the configured Responses backend; Remote V2 also sends active tool schemas.
 The Pi session stores the producing provider ID, encrypted compaction item, and bounded recent user-role Responses items.
 It does not store credentials, authorization headers, or request headers in checkpoint details.
 
 | Boundary | Limit |
 | --- | ---: |
-| Observed SSE stream | 8 MiB |
-| Serialized opaque compaction item | 2 MiB |
+| Observed SSE stream or unary JSON response | 8 MiB |
+| Serialized opaque compaction item or retained output item | 2 MiB |
 | Persisted replacement history | 8 MiB |
 | Retained user text | 64K approximate tokens by default; configurable from 8K to 128K |
 | Settings file | 64 KiB |
@@ -175,52 +183,29 @@ These hard byte ceilings are intentionally not configurable.
 
 ## 🚧 Limitations
 
-- The wire contract is undocumented and can change independently of Pi or this package.
-  Keep backups of important sessions.
-- Full older history depends on this extension, the `openai-codex-responses` API, the exact checkpoint model ID, and a provider route whose backend accepts the opaque item.
+- Codex Remote V2 remains an undocumented hosted contract and can change independently of Pi or this package; keep backups of important sessions.
+- Full older history depends on this extension, the checkpoint API label and compatibility profile, the exact checkpoint model ID, and a provider route whose backend accepts the opaque item.
   Removing the extension exposes only the portability fallback marker and Pi-retained recent messages.
 - The package does not reproduce Codex core's context-window UUID/number lineage, previous-model compatibility fallback, exact pre-turn ordering, or exact mid-turn model-session ownership.
+- Pi's public `getAllTools()` metadata does not expose `constrainedSampling`; Remote V2 preserves active tool order, names, descriptions, and parameter schemas but cannot reproduce that optional field.
 - Remote failure falls back to Pi's plaintext summary, so a session can contain both remote opaque and native compaction entries over time.
 - Settings concurrency is coordinated only within one Pi process; separate processes rely on the final conflict check.
 
-## 🗂️ Package layout
-
-```text
-src/index.ts          Thin Pi entrypoint
-src/codex-compact.ts  Pi lifecycle, command, provider projection, and fallback
-src/remote.ts         Provider stream invocation, auth payload, timeout, and retry controls
-src/protocol.ts       Bounded SSE parsing and Remote V2 payload/output validation
-src/checkpoint.ts     Replacement history, fingerprints, persistence, and replay projection
-src/model-api.ts      Codex Responses API detection for Remote V2 eligibility
-src/settings.ts       Global settings validation and atomic persistence
-src/settings-menu.ts  First-use manual compaction and settings TUI
-
-dist/                 Generated source-mapped Jiti runtime and lazy menu chunk
-scripts/              Runtime builder
-benchmark/            Three-arm compaction benchmark, self-test, and methodology
-test/                 Protocol, checkpoint, lifecycle, remote, settings, menu, and builder coverage
-```
-
 ## 📊 Benchmark
 
-The repository includes a seeded three-arm benchmark for uncompressed full context, Pi-native plaintext compaction, and this extension's Codex Remote Compaction V2 path.
-
-It holds history length nearly fixed while varying information density across five state categories and ten history epochs.
-
+The repository includes a seeded benchmark that compares uncompressed full context, Pi-native plaintext compaction, and this extension's Remote V2 path.
+It keeps history length nearly fixed while varying information density across five state categories and ten history epochs.
 Benchmark v3 uses repeated artifacts, isolated evaluator probes, seed-level paired statistics, one Pi SDK estimator for dry and live fixtures, and committed protocol manifests for confirmatory candidates.
-
 It never treats nominal Pi 20K and Codex 20K settings as equal information capacity or automatically claims that protocol-conformant evidence was genuinely held out.
 
 Preview its exploratory diagnostic without making a provider request:
 
 ```bash
-just benchmark-codex-compact
+npm run benchmark:codex-compact
 ```
 
-A live run requires an explicit `--live` flag, reviewed request and cost exposure, OpenAI Codex OAuth, and Remote V2 entitlement.
-
+A live run requires `--live`, review of the request and cost exposure, OpenAI Codex OAuth, and Remote V2 entitlement.
 The repository preserves the explicitly labeled v2 matched-tail diagnostic and the v3 calibration evidence, while seeds 301–304 remain consumed and unavailable for future confirmatory protocols.
-
 See the [benchmark guide](https://github.com/narumiruna/pi-extensions/tree/main/packages/pi-codex-compact/benchmark) for manifests, repetitions, commands, privacy, cost semantics, and interpretation limits.
 
 ## 🧪 Development
@@ -230,14 +215,29 @@ From the repository root:
 ```bash
 npm --workspace @narumitw/pi-codex-compact run check
 npm test
-just pack codex-compact
+npm run package:pack -- codex-compact
+```
+
+See the [Codex compaction mechanism notes](https://github.com/narumiruna/pi-extensions/blob/main/docs/implementation-notes/codex-compaction-mechanism.md) for the underlying Codex mechanism research and the extension boundary.
+
+## 🗂️ Package layout
+
+```text
+packages/pi-codex-compact/
+├── src/                               # Authoritative implementation and helpers
+│   ├── index.ts                       # Thin Pi entrypoint
+│   └── codex-compact.ts               # Compaction routing, replay, and fallback
+├── dist/                              # Generated Jiti runtime
+├── scripts/build-runtime.mjs          # Runtime builder
+├── benchmark/                         # Repository-only benchmark and methodology
+└── test/                              # Behavior and lifecycle coverage
 ```
 
-See [`docs/implementation-notes/codex-compaction-mechanism.md`](../../docs/implementation-notes/codex-compaction-mechanism.md) for the underlying Codex mechanism research and the extension boundary.
+The generated runtime is built from `src/index.ts` and does not import back into `src`.
 
 ## 🔎 Keywords
 
-Pi extension, Pi coding agent, OpenAI Codex, custom provider, proxy, Remote Compaction V2, opaque checkpoint, Responses API, context compaction.
+Pi extension, Pi coding agent, OpenAI Codex, Azure OpenAI, custom provider, proxy, Remote Compaction V2, Responses Compact API, opaque checkpoint, Responses API, context compaction.
 
 ## 📄 License
 

package/dist/chunks/chunk-7H7JJ7ZV.js

@@ -0,0 +1,37 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
+
+// src/model-api.ts
+function resolveResponsesCompactionProfile(api, apiProfiles = {}) {
+  if (api === "openai-codex-responses") return "codex-responses-v1";
+  if (api === "openai-responses" || api === "azure-openai-responses") return "openai-responses-v1";
+  return api && Object.hasOwn(apiProfiles, api) && apiProfiles[api] === "codex-responses-v1" ? "codex-responses-v1" : void 0;
+}
+function resolveCompactionRouteForApi(api, options) {
+  if (!options.enabled) return { kind: "native", reason: "remote compaction is disabled" };
+  if (!api) return { kind: "native", reason: "no active model" };
+  const profile = resolveResponsesCompactionProfile(api, options.apiProfiles);
+  if (!profile) {
+    return { kind: "native", reason: `API ${api} does not support Responses compaction` };
+  }
+  const protocol = options.protocol === "auto" ? profile === "codex-responses-v1" ? "remote-v2" : "responses-compact" : options.protocol;
+  return { kind: "remote", protocol, api, profile };
+}
+function resolveCompactionRoute(model, options) {
+  return resolveCompactionRouteForApi(model?.api, options);
+}
+
+// src/terminal.ts
+function terminalText(value) {
+  return Array.from(value, (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint < 32 || codePoint >= 127 && codePoint <= 159 ? " " : character;
+  }).join("");
+}
+
+export {
+  resolveCompactionRouteForApi,
+  resolveCompactionRoute,
+  terminalText
+};
+//# sourceMappingURL=chunk-7H7JJ7ZV.js.map

package/dist/chunks/chunk-7H7JJ7ZV.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/model-api.ts", "../../src/terminal.ts"],
+  "sourcesContent": ["import type { Api, Model } from \"@earendil-works/pi-ai\";\nimport type { CodexCompactSettings } from \"./settings.js\";\n\nexport const RESPONSES_COMPACTION_APIS = [\n  \"openai-codex-responses\",\n  \"openai-responses\",\n  \"azure-openai-responses\",\n] as const;\n\nexport type BuiltInResponsesCompactionApi = (typeof RESPONSES_COMPACTION_APIS)[number];\nexport type ResponsesCompactionApi = BuiltInResponsesCompactionApi;\nexport type ResponsesCompactionProfile = \"codex-responses-v1\" | \"openai-responses-v1\";\nexport type RemoteCompactionProtocol = \"remote-v2\" | \"responses-compact\";\nexport type RemoteCompactionProtocolSetting = \"auto\" | RemoteCompactionProtocol;\n\nexport type CompactionRoute =\n  | { kind: \"remote\"; protocol: RemoteCompactionProtocol; api: Api; profile: ResponsesCompactionProfile }\n  | { kind: \"native\"; reason: string };\n\nfunction resolveResponsesCompactionProfile(\n  api: Api | undefined,\n  apiProfiles: Readonly<Record<string, \"codex-responses-v1\">> = {},\n): ResponsesCompactionProfile | undefined {\n  if (api === \"openai-codex-responses\") return \"codex-responses-v1\";\n  if (api === \"openai-responses\" || api === \"azure-openai-responses\") return \"openai-responses-v1\";\n  return api && Object.hasOwn(apiProfiles, api) && apiProfiles[api] === \"codex-responses-v1\"\n    ? \"codex-responses-v1\"\n    : undefined;\n}\n\nexport function resolveCompactionRouteForApi(\n  api: Api | undefined,\n  options: Pick<CodexCompactSettings, \"enabled\" | \"protocol\"> & {\n    apiProfiles?: Readonly<Record<string, \"codex-responses-v1\">>;\n  },\n): CompactionRoute {\n  if (!options.enabled) return { kind: \"native\", reason: \"remote compaction is disabled\" };\n  if (!api) return { kind: \"native\", reason: \"no active model\" };\n  const profile = resolveResponsesCompactionProfile(api, options.apiProfiles);\n  if (!profile) {\n    return { kind: \"native\", reason: `API ${api} does not support Responses compaction` };\n  }\n  const protocol =\n    options.protocol === \"auto\"\n      ? profile === \"codex-responses-v1\"\n        ? \"remote-v2\"\n        : \"responses-compact\"\n      : options.protocol;\n  return { kind: \"remote\", protocol, api, profile };\n}\n\nexport function resolveCompactionRoute(\n  model: Model<Api> | undefined,\n  options: Pick<CodexCompactSettings, \"enabled\" | \"protocol\"> & {\n    apiProfiles?: Readonly<Record<string, \"codex-responses-v1\">>;\n  },\n): CompactionRoute {\n  return resolveCompactionRouteForApi(model?.api, options);\n}\n", "export function terminalText(value: string): string {\n  return Array.from(value, (character) => {\n    const codePoint = character.codePointAt(0) ?? 0;\n    return codePoint < 32 || (codePoint >= 127 && codePoint <= 159) ? \" \" : character;\n  }).join(\"\");\n}\n"],
+  "mappings": ";;;;AAmBA,SAAS,kCACP,KACA,cAA8D,CAAC,GACvB;AACxC,MAAI,QAAQ,yBAA0B,QAAO;AAC7C,MAAI,QAAQ,sBAAsB,QAAQ,yBAA0B,QAAO;AAC3E,SAAO,OAAO,OAAO,OAAO,aAAa,GAAG,KAAK,YAAY,GAAG,MAAM,uBAClE,uBACA;AACN;AAEO,SAAS,6BACd,KACA,SAGiB;AACjB,MAAI,CAAC,QAAQ,QAAS,QAAO,EAAE,MAAM,UAAU,QAAQ,gCAAgC;AACvF,MAAI,CAAC,IAAK,QAAO,EAAE,MAAM,UAAU,QAAQ,kBAAkB;AAC7D,QAAM,UAAU,kCAAkC,KAAK,QAAQ,WAAW;AAC1E,MAAI,CAAC,SAAS;AACZ,WAAO,EAAE,MAAM,UAAU,QAAQ,OAAO,GAAG,yCAAyC;AAAA,EACtF;AACA,QAAM,WACJ,QAAQ,aAAa,SACjB,YAAY,uBACV,cACA,sBACF,QAAQ;AACd,SAAO,EAAE,MAAM,UAAU,UAAU,KAAK,QAAQ;AAClD;AAEO,SAAS,uBACd,OACA,SAGiB;AACjB,SAAO,6BAA6B,OAAO,KAAK,OAAO;AACzD;;;AC1DO,SAAS,aAAa,OAAuB;AAClD,SAAO,MAAM,KAAK,OAAO,CAAC,cAAc;AACtC,UAAM,YAAY,UAAU,YAAY,CAAC,KAAK;AAC9C,WAAO,YAAY,MAAO,aAAa,OAAO,aAAa,MAAO,MAAM;AAAA,EAC1E,CAAC,EAAE,KAAK,EAAE;AACZ;",
+  "names": []
+}

package/dist/chunks/{settings-menu-PEDLURUH.js → settings-menu-TVWWDPBF.js}

@@ -1,31 +1,37 @@
 // @generated by scripts/build-runtime.mjs; do not edit.
 // @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
 import {
-  usesCodexResponsesApi
-} from "./chunk-6TZ2L2BM.js";
+  resolveCompactionRouteForApi,
+  terminalText
+} from "./chunk-7H7JJ7ZV.js";
 
 // src/settings-menu.ts
-function safeText(value) {
-  return Array.from(value, (character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    return codePoint < 32 || codePoint >= 127 && codePoint <= 159 ? " " : character;
-  }).join("");
-}
 function timeoutLabel(milliseconds) {
   return `${milliseconds / 6e4} min`;
 }
 function retentionLabel(tokens) {
   return `${tokens / 1e3}K tokens`;
 }
+function protocolLabel(protocol) {
+  switch (protocol) {
+    case "auto":
+      return "Auto";
+    case "remote-v2":
+      return "Remote V2";
+    case "responses-compact":
+      return "Responses Compact";
+  }
+}
 async function update(runtime, ctx, patch, signal) {
   try {
     await runtime.update(patch, signal);
-    ctx.ui.notify("Codex compaction settings saved.", "info");
+    if (signal.aborted) return { kind: "rejected" };
+    ctx.ui.notify("Responses compaction settings saved.", "info");
     return { kind: "stay" };
   } catch (error) {
     if (signal.aborted) return { kind: "rejected" };
     ctx.ui.notify(
-      `Could not save pi-codex-compact.json: ${safeText(error instanceof Error ? error.message : String(error))}`,
+      `Could not save pi-codex-compact.json: ${terminalText(error instanceof Error ? error.message : String(error))}`,
       "error"
     );
     return { kind: "rejected" };
@@ -37,11 +43,12 @@ function createCodexCompactMenu(runtime, options = {}) {
     screens: {
       main: ({ state }) => ({
         kind: "actions",
-        title: "Codex Remote Compaction",
+        title: "Responses Compaction",
         lines: [
-          `Remote V2: ${state.settings.enabled ? "On" : "Off"}`,
-          `Active model: ${safeText(options.status?.model ?? "none")}`,
-          `Compact route: ${safeText(compactRoute(state, options.status))}`
+          `Remote compaction: ${state.settings.enabled ? "On" : "Off"}`,
+          `Protocol setting: ${protocolLabel(state.settings.protocol)}`,
+          `Active model: ${terminalText(options.status?.model ?? "none")}`,
+          `Compact route: ${terminalText(compactRoute(state, options.status))}`
         ],
         items: [
           {
@@ -62,17 +69,25 @@ function createCodexCompactMenu(runtime, options = {}) {
       }),
       settings: ({ state }) => ({
         kind: "settings",
-        title: "Codex Remote Compaction Settings",
-        lines: [`User settings \xB7 ${safeText(state.path)}`],
+        title: "Responses Compaction Settings",
+        lines: [`User settings \xB7 ${terminalText(state.path)}`],
         items: [
           {
             id: "enabled",
             label: "Remote compaction",
-            description: "Use Codex Remote V2 when the model uses openai-codex-responses.",
+            description: "Use a supported Responses compaction protocol.",
             currentValue: state.settings.enabled ? "On" : "Off",
             values: ["On", "Off"],
             action: "set-enabled"
           },
+          {
+            id: "protocol",
+            label: "Protocol",
+            description: "Choose automatically or force one supported remote protocol.",
+            currentValue: protocolLabel(state.settings.protocol),
+            values: ["Auto", "Remote V2", "Responses Compact"],
+            action: "set-protocol"
+          },
           {
             id: "requestTimeoutMs",
             label: "Request timeout",
@@ -100,7 +115,7 @@ function createCodexCompactMenu(runtime, options = {}) {
           {
             id: "notifyOnFallback",
             label: "Fallback notifications",
-            description: "Warn when Remote V2 fails and native Pi compaction takes over.",
+            description: "Warn when remote compaction fails and Pi native takes over.",
             currentValue: state.settings.notifyOnFallback ? "On" : "Off",
             values: ["On", "Off"],
             action: "set-notify"
@@ -111,8 +126,8 @@ function createCodexCompactMenu(runtime, options = {}) {
         kind: "detail",
         title: "Codex Compact Settings \xB7 Read only",
         lines: [
-          `Invalid settings file: ${safeText(state.path)}`,
-          `Issue: ${safeText(state.issue ?? "unknown validation error")}`,
+          `Invalid settings file: ${terminalText(state.path)}`,
+          `Issue: ${terminalText(state.issue ?? "unknown validation error")}`,
           "Built-in defaults are active. Repair the file and run /reload; it will not be overwritten."
         ],
         hint: "back"
@@ -124,28 +139,29 @@ function createCodexCompactMenu(runtime, options = {}) {
         return { kind: "close" };
       },
       "set-enabled": ({ ctx, value, signal }) => update(runtime, ctx, { enabled: value === "On" }, signal),
-      "set-timeout": ({ ctx, value, signal }) => update(
+      "set-protocol": ({ ctx, value, signal }) => update(
         runtime,
         ctx,
-        { requestTimeoutMs: Number.parseInt(value ?? "5", 10) * 6e4 },
+        {
+          protocol: value === "Remote V2" ? "remote-v2" : value === "Responses Compact" ? "responses-compact" : "auto"
+        },
         signal
       ),
+      "set-timeout": ({ ctx, value, signal }) => update(runtime, ctx, { requestTimeoutMs: Number.parseInt(value ?? "5", 10) * 6e4 }, signal),
       "set-retries": ({ ctx, value, signal }) => update(runtime, ctx, { maxRetries: Number.parseInt(value ?? "2", 10) }, signal),
-      "set-retention": ({ ctx, value, signal }) => update(
-        runtime,
-        ctx,
-        { replacementTokenBudget: Number.parseInt(value ?? "64", 10) * 1e3 },
-        signal
-      ),
+      "set-retention": ({ ctx, value, signal }) => update(runtime, ctx, { replacementTokenBudget: Number.parseInt(value ?? "64", 10) * 1e3 }, signal),
       "set-notify": ({ ctx, value, signal }) => update(runtime, ctx, { notifyOnFallback: value === "On" }, signal)
     }
   };
 }
 async function showCodexCompactMenu(runtime, ctx, owner) {
-  if (ctx.mode !== "tui") {
-    ctx.ui.notify(`Edit Codex compaction settings at ${safeText(runtime.get().path)}.`, "info");
+  if (ctx.mode === "rpc" && ctx.hasUI) {
+    ctx.ui.notify(`Edit Responses compaction settings at ${terminalText(runtime.get().path)}.`, "info");
     return;
   }
+  if (ctx.mode !== "tui") {
+    throw new Error("/codex-compact requires TUI or RPC UI support");
+  }
   const { runMenu } = await import("@narumitw/pi-tui-kit");
   if (owner.signal.aborted || !owner.isCurrent()) return;
   let compactRequested = false;
@@ -167,7 +183,7 @@ async function showCodexCompactMenu(runtime, ctx, owner) {
   ctx.compact({
     onError: (error) => {
       if (!owner.signal.aborted && owner.isCurrent()) {
-        ctx.ui.notify(`Compaction failed: ${safeText(error.message)}`, "error");
+        ctx.ui.notify(`Compaction failed: ${terminalText(error.message)}`, "error");
       }
     }
   });
@@ -176,16 +192,17 @@ function compactMenuStatus(ctx) {
   const model = ctx.model;
   return {
     model: model ? `${model.provider}/${model.id}` : "none",
-    remoteEligible: usesCodexResponsesApi(model)
+    api: model?.api
   };
 }
 function compactRoute(state, status) {
-  if (!state.settings.enabled) return "Pi native (Remote V2 off)";
-  return status?.remoteEligible ? "Codex Remote V2" : "Pi native (requires openai-codex-responses)";
+  const route = resolveCompactionRouteForApi(status?.api, state.settings);
+  if (route.kind === "native") return `Pi native (${route.reason})`;
+  return route.protocol === "remote-v2" ? "Responses Remote V2" : "Responses Compact API";
 }
 export {
   compactMenuStatus,
   createCodexCompactMenu,
   showCodexCompactMenu
 };
-//# sourceMappingURL=settings-menu-PEDLURUH.js.map
+//# sourceMappingURL=settings-menu-TVWWDPBF.js.map

package/dist/chunks/settings-menu-TVWWDPBF.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/settings-menu.ts"],
+  "sourcesContent": ["import type { Api } from \"@earendil-works/pi-ai\";\nimport type { ExtensionCommandContext } from \"@earendil-works/pi-coding-agent\";\nimport type { MenuDefinition } from \"@narumitw/pi-tui-kit\";\nimport { resolveCompactionRouteForApi } from \"./model-api.js\";\nimport type { CodexCompactSettings, CodexCompactSettingsRuntime, CodexCompactSettingsState } from \"./settings.js\";\nimport { terminalText as safeText } from \"./terminal.js\";\n\ntype Screen = \"main\" | \"settings\" | \"invalid\";\ntype Action =\n  | \"compact-now\"\n  | \"set-enabled\"\n  | \"set-protocol\"\n  | \"set-timeout\"\n  | \"set-retries\"\n  | \"set-retention\"\n  | \"set-notify\";\n\nexport interface SettingsMenuOwner {\n  signal: AbortSignal;\n  isCurrent(): boolean;\n}\n\ninterface CompactMenuStatus {\n  model: string;\n  api?: Api;\n}\n\nfunction timeoutLabel(milliseconds: number): string {\n  return `${milliseconds / 60_000} min`;\n}\n\nfunction retentionLabel(tokens: number): string {\n  return `${tokens / 1000}K tokens`;\n}\n\nfunction protocolLabel(protocol: CodexCompactSettings[\"protocol\"]): string {\n  switch (protocol) {\n    case \"auto\":\n      return \"Auto\";\n    case \"remote-v2\":\n      return \"Remote V2\";\n    case \"responses-compact\":\n      return \"Responses Compact\";\n  }\n}\n\nasync function update(\n  runtime: CodexCompactSettingsRuntime,\n  ctx: ExtensionCommandContext,\n  patch: Partial<CodexCompactSettings>,\n  signal: AbortSignal,\n) {\n  try {\n    await runtime.update(patch, signal);\n    if (signal.aborted) return { kind: \"rejected\" as const };\n    ctx.ui.notify(\"Responses compaction settings saved.\", \"info\");\n    return { kind: \"stay\" as const };\n  } catch (error) {\n    if (signal.aborted) return { kind: \"rejected\" as const };\n    ctx.ui.notify(\n      `Could not save pi-codex-compact.json: ${safeText(error instanceof Error ? error.message : String(error))}`,\n      \"error\",\n    );\n    return { kind: \"rejected\" as const };\n  }\n}\n\nexport function createCodexCompactMenu(\n  runtime: CodexCompactSettingsRuntime,\n  options: { onCompactRequested?: () => void; status?: CompactMenuStatus } = {},\n): MenuDefinition<CodexCompactSettingsState, Screen, Action, ExtensionCommandContext> {\n  return {\n    start: \"main\",\n    screens: {\n      main: ({ state }) => ({\n        kind: \"actions\",\n        title: \"Responses Compaction\",\n        lines: [\n          `Remote compaction: ${state.settings.enabled ? \"On\" : \"Off\"}`,\n          `Protocol setting: ${protocolLabel(state.settings.protocol)}`,\n          `Active model: ${safeText(options.status?.model ?? \"none\")}`,\n          `Compact route: ${safeText(compactRoute(state, options.status))}`,\n        ],\n        items: [\n          {\n            id: \"compact-now\",\n            label: \"Compact now\",\n            description: \"Close this menu and compact the active session immediately.\",\n            action: \"compact-now\",\n          },\n          state.kind === \"invalid\"\n            ? {\n                id: \"settings\",\n                label: \"Settings\",\n                description: \"Read-only until the invalid settings file is repaired.\",\n                to: \"invalid\" as const,\n              }\n            : { id: \"settings\", label: \"Settings\", to: \"settings\" as const },\n          { id: \"close\", label: \"Close\", close: true },\n        ],\n        hint: \"close\",\n      }),\n      settings: ({ state }) => ({\n        kind: \"settings\",\n        title: \"Responses Compaction Settings\",\n        lines: [`User settings \u00B7 ${safeText(state.path)}`],\n        items: [\n          {\n            id: \"enabled\",\n            label: \"Remote compaction\",\n            description: \"Use a supported Responses compaction protocol.\",\n            currentValue: state.settings.enabled ? \"On\" : \"Off\",\n            values: [\"On\", \"Off\"],\n            action: \"set-enabled\",\n          },\n          {\n            id: \"protocol\",\n            label: \"Protocol\",\n            description: \"Choose automatically or force one supported remote protocol.\",\n            currentValue: protocolLabel(state.settings.protocol),\n            values: [\"Auto\", \"Remote V2\", \"Responses Compact\"],\n            action: \"set-protocol\",\n          },\n          {\n            id: \"requestTimeoutMs\",\n            label: \"Request timeout\",\n            description: \"Maximum time for the extension-owned remote compaction request.\",\n            currentValue: timeoutLabel(state.settings.requestTimeoutMs),\n            values: [\"2 min\", \"5 min\", \"10 min\"],\n            action: \"set-timeout\",\n          },\n          {\n            id: \"maxRetries\",\n            label: \"Transport retries\",\n            description: \"Retry transient provider failures before falling back to Pi.\",\n            currentValue: String(state.settings.maxRetries),\n            values: [\"0\", \"1\", \"2\"],\n            action: \"set-retries\",\n          },\n          {\n            id: \"replacementTokenBudget\",\n            label: \"Retained user history\",\n            description: \"Approximate user-message budget kept beside the opaque checkpoint.\",\n            currentValue: retentionLabel(state.settings.replacementTokenBudget),\n            values: [\"32K tokens\", \"64K tokens\", \"96K tokens\", \"128K tokens\"],\n            action: \"set-retention\",\n          },\n          {\n            id: \"notifyOnFallback\",\n            label: \"Fallback notifications\",\n            description: \"Warn when remote compaction fails and Pi native takes over.\",\n            currentValue: state.settings.notifyOnFallback ? \"On\" : \"Off\",\n            values: [\"On\", \"Off\"],\n            action: \"set-notify\",\n          },\n        ],\n      }),\n      invalid: ({ state }) => ({\n        kind: \"detail\",\n        title: \"Codex Compact Settings \u00B7 Read only\",\n        lines: [\n          `Invalid settings file: ${safeText(state.path)}`,\n          `Issue: ${safeText(state.issue ?? \"unknown validation error\")}`,\n          \"Built-in defaults are active. Repair the file and run /reload; it will not be overwritten.\",\n        ],\n        hint: \"back\",\n      }),\n    },\n    actions: {\n      \"compact-now\": async () => {\n        options.onCompactRequested?.();\n        return { kind: \"close\" };\n      },\n      \"set-enabled\": ({ ctx, value, signal }) => update(runtime, ctx, { enabled: value === \"On\" }, signal),\n      \"set-protocol\": ({ ctx, value, signal }) =>\n        update(\n          runtime,\n          ctx,\n          {\n            protocol:\n              value === \"Remote V2\" ? \"remote-v2\" : value === \"Responses Compact\" ? \"responses-compact\" : \"auto\",\n          },\n          signal,\n        ),\n      \"set-timeout\": ({ ctx, value, signal }) =>\n        update(runtime, ctx, { requestTimeoutMs: Number.parseInt(value ?? \"5\", 10) * 60_000 }, signal),\n      \"set-retries\": ({ ctx, value, signal }) =>\n        update(runtime, ctx, { maxRetries: Number.parseInt(value ?? \"2\", 10) }, signal),\n      \"set-retention\": ({ ctx, value, signal }) =>\n        update(runtime, ctx, { replacementTokenBudget: Number.parseInt(value ?? \"64\", 10) * 1000 }, signal),\n      \"set-notify\": ({ ctx, value, signal }) => update(runtime, ctx, { notifyOnFallback: value === \"On\" }, signal),\n    },\n  };\n}\n\nexport async function showCodexCompactMenu(\n  runtime: CodexCompactSettingsRuntime,\n  ctx: ExtensionCommandContext,\n  owner: SettingsMenuOwner,\n): Promise<void> {\n  if (ctx.mode === \"rpc\" && ctx.hasUI) {\n    ctx.ui.notify(`Edit Responses compaction settings at ${safeText(runtime.get().path)}.`, \"info\");\n    return;\n  }\n  if (ctx.mode !== \"tui\") {\n    throw new Error(\"/codex-compact requires TUI or RPC UI support\");\n  }\n  const { runMenu } = await import(\"@narumitw/pi-tui-kit\");\n  if (owner.signal.aborted || !owner.isCurrent()) return;\n  let compactRequested = false;\n  await runMenu(\n    ctx,\n    createCodexCompactMenu(runtime, {\n      onCompactRequested: () => {\n        compactRequested = true;\n      },\n      status: compactMenuStatus(ctx),\n    }),\n    {\n      getState: () => runtime.get(),\n      signal: owner.signal,\n      isCurrent: owner.isCurrent,\n    },\n  );\n  if (!compactRequested || owner.signal.aborted || !owner.isCurrent()) return;\n  ctx.compact({\n    onError: (error) => {\n      if (!owner.signal.aborted && owner.isCurrent()) {\n        ctx.ui.notify(`Compaction failed: ${safeText(error.message)}`, \"error\");\n      }\n    },\n  });\n}\n\nexport function compactMenuStatus(ctx: ExtensionCommandContext): CompactMenuStatus {\n  const model = ctx.model;\n  return {\n    model: model ? `${model.provider}/${model.id}` : \"none\",\n    api: model?.api,\n  };\n}\n\nfunction compactRoute(state: Readonly<CodexCompactSettingsState>, status: CompactMenuStatus | undefined): string {\n  const route = resolveCompactionRouteForApi(status?.api, state.settings);\n  if (route.kind === \"native\") return `Pi native (${route.reason})`;\n  return route.protocol === \"remote-v2\" ? \"Responses Remote V2\" : \"Responses Compact API\";\n}\n"],
+  "mappings": "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",
+  "names": []
+}