pi-cache-optimizer 2.8.17 → 2.8.19

package/README.md

@@ -62,7 +62,7 @@ Run `/reload` in Pi after install/update/remove so extension hooks refresh.
 
 On Pi 0.79.7 and newer, `pi update` updates Pi itself only. To update installed Pi packages such as this extension, run `pi update --extensions` (packages only) or `pi update --all` (Pi + packages).
 
-This extension requires Pi 0.82+ and is validated against Pi 1.0.0. It uses the official Pi package types directly for type-checking, along with extension hooks, `getAgentDir()`, and prompt options shared by those versions; it does not depend on Pi 0.83+ APIs such as `ctx.scopedModels` or the bundled TypeBox 1.3 aliases. Native virtual model support and codemode nested-call coalescing activate only on Pi 0.99+ hosts that produce them; older hosts keep the previous behavior. The local development baseline uses Node.js 22.19.0 or newer, matching Pi 1.0.0's engine requirement.
+This extension requires Pi 0.82+ and is validated against Pi 1.0.2. It uses the official Pi package types directly for type-checking, along with extension hooks, `getAgentDir()`, and prompt options shared by those versions; it does not depend on Pi 0.83+ APIs such as `ctx.scopedModels` or the bundled TypeBox 1.3 aliases. Native virtual model support and codemode nested-call coalescing activate only on Pi 0.99+ hosts that produce them; older hosts keep the previous behavior. The local development baseline uses Node.js 22.19.0 or newer, matching Pi 1.0.2's engine requirement.
 
 ## Commands
 
@@ -110,6 +110,8 @@ Persistent feature settings are managed under the Pi agent directory by the nati
 /cache-optimizer config reset
 ```
 
+`openai-codex-responses` keeps Pi's native skill index even when skill compression is enabled. Real task-level benchmarks with `openai-codex/gpt-6-luna` showed that the shorter Markdown skill index could increase the model's tool-call trajectory and total task cost; Codex therefore keeps the native Pi XML skill list while still benefiting from the optimizer's other cache/runtime features.
+
 `config reset` reads the latest disk configuration under the shared transaction lock and removes only persistent feature overrides, preserving the latest footer mode, model-specific prompt-cache-key settings, and file permissions. Invalid JSON/schema, symlinks, non-regular targets, and concurrent manual changes are refused rather than overwritten. These commands do not modify shell startup files or `PI_CACHE_RETENTION`; `enable` and `disable` remain current-process runtime switches.
 
 ## Opt-in deterministic tool ordering
@@ -130,17 +132,17 @@ The fixture verifier reports numeric tool-order changes and confirms cache-marke
 
 ## Footer cache stats mode
 
-Current versions store stats under `pi-cache-optimizer-stats.d/shards/` in Pi's agent directory. Each loaded extension instance owns one UUID-named shard and writes it through temp-file + atomic rename. This prevents parent/child/parallel Pi processes from overwriting one another. Upgrading from the old v6 single-file format deletes the old local stats files and starts footer counters from zero; upstream provider caches are not affected.
+Current versions store stats under `pi-cache-optimizer-stats.d/shards/` in Pi's agent directory. Each loaded extension instance owns one active UUID-named daily shard and writes it through temp-file + atomic rename; at local midnight it closes the old shard and starts a new UUID without erasing session history. This prevents parent/child/parallel Pi processes from overwriting one another. Upgrading from the old v6 single-file format deletes the old local stats files and starts footer counters from zero; upstream provider caches are not affected.
 
-Response stats stay with the dispatched catalog/request-local model even if you switch to another model on the same provider while waiting. Legacy response aliases use the request snapshot, not the new selection; the footer continues showing the selected direct model. Old corrupt JSON/schema shards expire by file modification time after 48 hours; young corrupt files, valid current-day shards, live old instances, and symlink targets remain protected.
+Response stats stay with the dispatched catalog/request-local model even if you switch to another model on the same provider while waiting. Legacy response aliases use the request snapshot, not the new selection; the footer continues showing the selected direct model. Old corrupt JSON/schema shards expire by file modification time after two months; young corrupt files, valid current-day shards, live old instances, and symlink targets remain protected.
 
 The footer defaults to `session`, which reflects the current Pi conversation rather than another parallel Pi terminal using the same provider/model. Use either the command or environment variable to select the scope:
 
 | Value | Effect |
 |---|---|
-| `session` (default) | Aggregate today's shards carrying the current hashed Pi conversation session id and exact provider/model. A reload creates a new instance shard but remains in the same session scope. |
-| `total` | Aggregate today's valid local shards for the exact provider/model across sessions, including child Pi agents that load this extension and share the same agent directory. |
-| `process` | Show only counters collected by the current extension instance. It starts at `0/0` after Pi restart or extension reload. |
+| `session` (default) | Aggregate all retained shards carrying the current hashed Pi conversation session id and exact provider/model, including across local-day boundaries. A reload creates a new instance shard but remains in the same lifetime session scope. |
+| `total` | Aggregate the current local day's valid shards for the exact provider/model across sessions, including child Pi agents that load this extension and share the same agent directory. |
+| `process` | Show only today's counters collected by the current extension instance. It starts at `0/0` at local midnight, after Pi restart, or extension reload. |
 
 Persistent command configuration takes precedence over the environment variable:
 
@@ -154,7 +156,7 @@ The explicit setting is stored in `pi-cache-optimizer-config.json` under Pi's ag
 
 ## Per-model `prompt_cache_key` opt-out
 
-Some OpenAI-compatible Completions endpoints reject `prompt_cache_key` with HTTP 400 even though the same field is valid for other providers. Pi 1.0.0 owns the key for Responses/Codex transports; this extension's key opt-out and fallback apply only to `openai-completions`. Pi 1.0.0 has no native `supportsPromptCacheKey` compat field; do **not** add that unknown field to `models.json`. `supportsLongCacheRetention` is not an equivalent switch and should not be used for this purpose.
+Some OpenAI-compatible Completions endpoints reject `prompt_cache_key` with HTTP 400 even though the same field is valid for other providers. Pi 1.0.2 owns the key for Responses/Codex transports; this extension's key opt-out and fallback apply only to `openai-completions`. Pi 1.0.2 has no native `supportsPromptCacheKey` compat field; do **not** add that unknown field to `models.json`. `supportsLongCacheRetention` is not an equivalent switch and should not be used for this purpose.
 
 When the extension observes an explicit field-level `prompt_cache_key` unsupported error for the exact provider/model, ordinary `/cache-optimizer fix` offers a confirmed model-scoped repair. Value-validation failures and conditional restrictions such as “not allowed when temperature is set” do not qualify. If concurrent responses from different models cannot be correlated because Pi provides no request ID, header-only evidence is ignored unless the finalized assistant message supplies exact provider/model identity. If you already know that the endpoint rejects the field, use the explicit command:
 
@@ -194,7 +196,7 @@ Notes:
 
 - `sendSessionAffinityHeaders: true` is the safe default when your proxy supports sticky routing.
 - `supportsLongCacheRetention: true` is optional. Add it only when the endpoint explicitly supports OpenAI long prompt cache retention.
-- Do not add `supportsPromptCacheKey` to `models.json`: Pi 1.0.0 does not define that compat field. Use `/cache-optimizer fix prompt-cache-key` to store an exact provider/model omit rule in the extension-owned config; it removes both key spellings, including a key supplied by Pi.
+- Do not add `supportsPromptCacheKey` to `models.json`: Pi 1.0.2 does not define that compat field. Use `/cache-optimizer fix prompt-cache-key` to store an exact provider/model omit rule in the extension-owned config; it removes both key spellings, including a key supplied by Pi.
 - If you see `400 Unsupported parameter: prompt_cache_retention`, remove/avoid `supportsLongCacheRetention` for that channel. Keep `sendSessionAffinityHeaders` if supported. The extension detects the explicit error from response headers or the finalized assistant error message and strips the parameter from subsequent requests in the current process.
 - Use `/cache-optimizer compat` or `/cache-optimizer doctor` to see model-specific advice.
 - DeepSeek model names select the `DS cache` adapter only; they do not prove a reasoning wire protocol. Generic cache/routing advice remains active for absent or non-DeepSeek formats. DeepSeek replay advice is shown only when effective `compat.thinkingFormat: "deepseek"` is explicitly configured; it never treats `thinkingFormat` as a missing fix key.
@@ -362,7 +364,7 @@ Rollback creates a new access-mode-preserving backup and uses atomic replacement
 
 ## Footer stats
 
-Stats are read-only local counters stored as UUID-owned shards under `pi-cache-optimizer-stats.d/shards/` in Pi's agent directory (custom agent dirs use `PI_CODING_AGENT_DIR`). Shards contain only dates, opaque session hashes, exact provider/model counters, reset epochs, and process lifecycle metadata — no API keys, prompts, payloads, headers, responses, or model output. The footer defaults to the current conversation session; `total` aggregates all valid current-day shards for the exact provider/model, and `process` shows only the current extension instance. Footer mode configuration is stored separately in `pi-cache-optimizer-config.json`. Upgrading from the old v6 shared stats files deletes those local counters instead of migrating them.
+Stats are read-only local counters stored as UUID-owned shards under `pi-cache-optimizer-stats.d/shards/` in Pi's agent directory (custom agent dirs use `PI_CODING_AGENT_DIR`). Shards contain only dates, opaque session hashes, exact provider/model counters, reset epochs, and process lifecycle metadata — no API keys, prompts, payloads, headers, responses, or model output. The footer defaults to the current conversation session and retains that session's counters across local-day boundaries; `total` aggregates only current-day shards, and `process` shows only the current extension instance. Footer mode configuration is stored separately in `pi-cache-optimizer-config.json`. Upgrading from the old v6 shared stats files deletes those local counters instead of migrating them.
 
 Pi 0.79+ also includes a built-in footer `CH` marker for the latest prompt cache hit rate. This extension complements that marker with persisted provider/model counters plus proxy compat diagnostics.
 

package/README.zh-CN.md

@@ -62,7 +62,7 @@ pi remove npm:pi-deepseek-cache-optimizer && pi install npm:pi-cache-optimizer
 
 Pi 0.79.7 及之后，`pi update` 默认只更新 Pi 本体。若要更新已安装的 Pi package（包括本扩展），请运行 `pi update --extensions`（只更新 packages）或 `pi update --all`（Pi 与 packages 一起更新）。
 
-本扩展要求 Pi 0.82+，并已使用 Pi 1.0.0 验证。TypeScript 校验直接使用官方 Pi package 类型，同时只使用这些版本共有的 extension hooks、`getAgentDir()` 和 prompt options；不依赖 Pi 0.83+ 专有 API（例如 `ctx.scopedModels` 或 bundled TypeBox 1.3 aliases）。原生虚拟模型支持与 codemode 嵌套工具调用合并只在会产生它们的 Pi 0.99+ 上生效，较早版本保持原有行为。本地开发基线需要 Node.js 22.19.0 或更高版本，与 Pi 1.0.0 的 engine 要求一致。
+本扩展要求 Pi 0.82+，并已使用 Pi 1.0.2 验证。TypeScript 校验直接使用官方 Pi package 类型，同时只使用这些版本共有的 extension hooks、`getAgentDir()` 和 prompt options；不依赖 Pi 0.83+ 专有 API（例如 `ctx.scopedModels` 或 bundled TypeBox 1.3 aliases）。原生虚拟模型支持与 codemode 嵌套工具调用合并只在会产生它们的 Pi 0.99+ 上生效，较早版本保持原有行为。本地开发基线需要 Node.js 22.19.0 或更高版本，与 Pi 1.0.2 的 engine 要求一致。
 
 ## 命令
 
@@ -110,6 +110,8 @@ Doctor 显示的 endpoint URL 会移除用户名/密码、查询参数和 fragme
 /cache-optimizer config reset
 ```
 
+对于 `openai-codex-responses`，即使开启 skill compression，也会保留 Pi 原生 skill index。真实 `openai-codex/gpt-6-luna` 任务级 benchmark 表明，较短的 Markdown skill index 虽然减少了单次 prompt，但可能增加模型的工具调用轨迹和最终任务总成本；因此 Codex 保留 Pi 原生 XML skill 列表，同时继续使用本扩展的其他缓存与运行时优化。
+
 `config reset` 在共享事务锁内读取最新磁盘配置，只移除持久化 feature 覆盖，保留最新 footer mode、按模型配置的 prompt-cache-key 设置和文件权限。JSON/schema 无效、symlink、非普通文件或并发手动修改时会拒绝覆盖。这些命令不会修改 shell 启动文件或 `PI_CACHE_RETENTION`；`enable` 和 `disable` 仍然是当前进程的运行时开关。
 
 ## Opt-in 确定性工具排序
@@ -130,17 +132,17 @@ bun .trellis/tasks/09-03-context-epoch-tool-ordering/verify.ts
 
 ## Footer 缓存统计模式
 
-当前版本把统计保存在 Pi agent 目录的 `pi-cache-optimizer-stats.d/shards/` 下。每个已加载的 extension instance 独占一个 UUID 命名 shard，并通过临时文件 + 原子 rename 写入，因此父/子/并行 Pi 进程不会互相覆盖。旧 v6 单文件统计在升级时直接删除，本地 footer 计数从零开始；不会影响上游 provider 的实际缓存。
+当前版本把统计保存在 Pi agent 目录的 `pi-cache-optimizer-stats.d/shards/` 下。每个已加载的 extension instance 独占一个当天的活跃 UUID shard，并通过临时文件 + 原子 rename 写入；本地日期切换时关闭旧 shard、创建新的 UUID，保留 session 历史，因此父/子/并行 Pi 进程不会互相覆盖。旧 v6 单文件统计在升级时直接删除，本地 footer 计数从零开始；不会影响上游 provider 的实际缓存。
 
-即使等待响应时切换到同一 provider 的另一个模型，响应统计仍归属于实际请求的 catalog/request-local 模型。旧 transport 的响应别名只根据请求快照处理，不使用新选择的模型；footer 继续显示当前选择的 direct 模型。损坏 JSON/schema 的旧 shard 按文件修改时间在 48 小时后清理；较新的损坏文件、有效的当天 shard、仍存活的旧 instance 和 symlink 目标均受保护。
+即使等待响应时切换到同一 provider 的另一个模型，响应统计仍归属于实际请求的 catalog/request-local 模型。旧 transport 的响应别名只根据请求快照处理，不使用新选择的模型；footer 继续显示当前选择的 direct 模型。损坏 JSON/schema 的旧 shard 按文件修改时间在两个月后清理；较新的损坏文件、有效的当天 shard、仍存活的旧 instance 和 symlink 目标均受保护。
 
 Footer 默认使用 `session`，避免另一个并行 Pi 终端使用相同 provider/model 时污染当前窗口。可以通过命令或环境变量切换显示范围：
 
 | 值 | 作用 |
 |---|---|
-| `session`（默认） | 聚合今天携带当前 hashed Pi conversation session id 且精确 provider/model 相同的 shard。Extension reload 会产生新 instance shard，但仍属于同一 session 范围。 |
-| `total` | 聚合今天同一精确 provider/model 的全部有效本地 shard，包括加载本扩展并共享同一 agent 目录的子 Pi agent。 |
-| `process` | 仅显示当前 extension instance 采集的统计。Pi 重启或 extension reload 后从 `0/0` 开始。 |
+| `session`（默认） | 聚合所有携带当前 hashed Pi conversation session id 且精确 provider/model 相同的保留 shard，跨越本地日期仍会累计。Extension reload 会产生新 instance shard，但仍属于同一长期 session 范围。 |
+| `total` | 聚合当前本地日期同一精确 provider/model 的全部有效本地 shard，包括加载本扩展并共享同一 agent 目录的子 Pi agent。 |
+| `process` | 仅显示当前 extension instance 当天采集的统计。本地日期切换、Pi 重启或 extension reload 后从 `0/0` 开始。 |
 
 持久命令配置优先于环境变量：
 
@@ -154,7 +156,7 @@ Footer 默认使用 `session`，避免另一个并行 Pi 终端使用相同 prov
 
 ## 按模型关闭 `prompt_cache_key`
 
-某些 OpenAI-compatible Completions endpoint 会因 `prompt_cache_key` 返回 HTTP 400，但同一个字段对其他 provider 可能有效。Pi 1.0+ 已负责 Responses/Codex transport 的 key；本扩展的 fallback 和 opt-out 只作用于 `openai-completions`。Pi 1.0.0 没有原生的 `supportsPromptCacheKey` compat 字段，**不要**把这个未知字段加入 `models.json`。`supportsLongCacheRetention` 也不是等价开关，不应借用来实现此目的。
+某些 OpenAI-compatible Completions endpoint 会因 `prompt_cache_key` 返回 HTTP 400，但同一个字段对其他 provider 可能有效。Pi 1.0+ 已负责 Responses/Codex transport 的 key；本扩展的 fallback 和 opt-out 只作用于 `openai-completions`。Pi 1.0.2 没有原生的 `supportsPromptCacheKey` compat 字段，**不要**把这个未知字段加入 `models.json`。`supportsLongCacheRetention` 也不是等价开关，不应借用来实现此目的。
 
 当扩展观察到精确 provider/model 对 `prompt_cache_key` 的明确字段级拒绝后，普通 `/cache-optimizer fix` 会提供经过确认的模型级修复。参数值校验失败，以及“设置 temperature 时不允许”这类条件限制都不构成证据。若不同模型的响应并发交错，而 Pi 又没有提供 request ID，扩展会忽略无法安全关联的 response-header 证据；只有最终 assistant message 提供精确 provider/model 身份时才恢复归因。如果你已经确定 endpoint 不支持该字段，可以主动执行：
 
@@ -168,7 +170,7 @@ Footer 默认使用 `session`，避免另一个并行 Pi 终端使用相同 prov
 
 LiteLLM / OneAPI / NewAPI / 类 OpenRouter 渠道等第三方 `openai-completions` 代理，常会把同一个 session 分散到多个上游后端，导致 provider 侧 prompt cache 被拆散。
 
-Pi 0.84.1 还修复了内置 Fireworks 渠道对拒绝 `prompt_cache_retention` 的模型兼容性；本扩展不按 provider 名称增加特殊分支，而是结合 `models.json` 与 runtime model，按精确 provider/model 解析有效 compat。Pi 0.81+ 也内置了使用 OpenAI-shaped transport 的 `llama.cpp` provider。本扩展只对第三方 `openai-completions` 保留 session-id key fallback；Pi 1.0+ 已负责 Responses/Codex transport 的 key。只有符合 Pi 内置 provider 明确 compat 指纹的模型会跳过通用 proxy 路由 / session-affinity 建议；仅复用 `llama.cpp` id 的自定义或覆盖 provider 仍按普通 OpenAI-compatible 渠道处理。`prompt_cache_retention` 继续遵循统一安全规则：仅官方 OpenAI 或 `models.json` 中有效配置为 `supportsLongCacheRetention: true` 时保留，否则发送前移除。Pi 1.0.0 没有原生的 `supportsPromptCacheKey` compat 字段，因此仅对 `openai-completions` 按模型关闭 key 的策略保存在本扩展的 `pi-cache-optimizer-config.json` 中，而不是 `models.json`。扩展配置独立于 Pi 的 compat 优先级，只影响其中列出的精确 provider/model。
+Pi 0.84.1 还修复了内置 Fireworks 渠道对拒绝 `prompt_cache_retention` 的模型兼容性；本扩展不按 provider 名称增加特殊分支，而是结合 `models.json` 与 runtime model，按精确 provider/model 解析有效 compat。Pi 0.81+ 也内置了使用 OpenAI-shaped transport 的 `llama.cpp` provider。本扩展只对第三方 `openai-completions` 保留 session-id key fallback；Pi 1.0+ 已负责 Responses/Codex transport 的 key。只有符合 Pi 内置 provider 明确 compat 指纹的模型会跳过通用 proxy 路由 / session-affinity 建议；仅复用 `llama.cpp` id 的自定义或覆盖 provider 仍按普通 OpenAI-compatible 渠道处理。`prompt_cache_retention` 继续遵循统一安全规则：仅官方 OpenAI 或 `models.json` 中有效配置为 `supportsLongCacheRetention: true` 时保留，否则发送前移除。Pi 1.0.2 没有原生的 `supportsPromptCacheKey` compat 字段，因此仅对 `openai-completions` 按模型关闭 key 的策略保存在本扩展的 `pi-cache-optimizer-config.json` 中，而不是 `models.json`。扩展配置独立于 Pi 的 compat 优先级，只影响其中列出的精确 provider/model。
 
 对真正的代理，建议先启用 session affinity：
 
@@ -194,7 +196,7 @@ Pi 0.84.1 还修复了内置 Fireworks 渠道对拒绝 `prompt_cache_retention`
 
 - `sendSessionAffinityHeaders: true` 是安全默认项，前提是你的代理支持 sticky routing。
 - `supportsLongCacheRetention: true` 是可选项。只有 endpoint 明确支持 OpenAI long prompt cache retention 时才添加。
-- 不要把 `supportsPromptCacheKey` 加入 `models.json`：Pi 1.0.0 没有定义这个 compat 字段。请使用 `/cache-optimizer fix prompt-cache-key` 在扩展自有配置中保存精确 provider/model 的 omit 规则；它会移除两种 key 写法，包括 Pi 提供的 key。
+- 不要把 `supportsPromptCacheKey` 加入 `models.json`：Pi 1.0.2 没有定义这个 compat 字段。请使用 `/cache-optimizer fix prompt-cache-key` 在扩展自有配置中保存精确 provider/model 的 omit 规则；它会移除两种 key 写法，包括 Pi 提供的 key。
 - 如果出现 `400 Unsupported parameter: prompt_cache_retention`，请为该渠道移除 / 避免 `supportsLongCacheRetention`；如支持，可保留 `sendSessionAffinityHeaders`。扩展会从响应头或最终 assistant error message 中识别这条明确错误，并在当前进程的后续请求中移除该参数。
 - 使用 `/cache-optimizer compat` 或 `/cache-optimizer doctor` 查看当前模型的具体建议。
 - DeepSeek 模型名只用于选择 `DS cache` adapter，不能证明 reasoning wire protocol。缺少或使用非 DeepSeek format 时仍保留通用缓存 / 路由建议；只有 effective `compat.thinkingFormat: "deepseek"` 被明确配置时，才显示 DeepSeek replay 建议，且不会把 `thinkingFormat` 列为缺失修复项。
@@ -361,7 +363,7 @@ Rollback 会创建新的、保留访问权限的备份并使用原子替换。
 
 ## Footer 统计
 
-统计是只读本地计数，保存在 Pi agent 目录的 UUID shard（`pi-cache-optimizer-stats.d/shards/`；自定义 agent 目录使用 `PI_CODING_AGENT_DIR`）。Shard 只包含日期、opaque session hash、精确 provider/model 计数、reset epoch 和进程生命周期元数据，不包含 API key、prompt、payload、headers、响应或模型输出。Footer 默认显示当前 conversation session；`total` 聚合同一精确 provider/model 的所有有效本地 shard，`process` 只显示当前 extension instance。旧 v6 共享统计文件升级时直接删除，不迁移旧计数。
+统计是只读本地计数，保存在 Pi agent 目录的 UUID shard（`pi-cache-optimizer-stats.d/shards/`；自定义 agent 目录使用 `PI_CODING_AGENT_DIR`）。Shard 只包含日期、opaque session hash、精确 provider/model 计数、reset epoch 和进程生命周期元数据，不包含 API key、prompt、payload、headers、响应或模型输出。Footer 默认显示当前 conversation session，并跨本地日期累计该 session；`total` 只聚合当前本地日期的同一精确 provider/model shard，`process` 只显示当前 extension instance。旧 v6 共享统计文件升级时直接删除，不迁移旧计数。
 
 Pi 0.79+ 已内置 footer `CH` 标记，用于显示最近一次 prompt cache hit rate。本扩展在此基础上补充持久化的 provider/model 计数，以及代理 compat 诊断。
 

package/index.ts

@@ -443,9 +443,13 @@ export default function (pi: ExtensionAPI) {
   let shardRefreshTimer: ReturnType<typeof setTimeout> | null = null;
   let shardWatcher: ReturnType<typeof watch> | undefined;
   const enqueuePersist = createSerializedAsyncRunner();
-  const instanceId = randomUUID();
+  let instanceId = randomUUID();
   const instanceStartedAt = Date.now();
-  const instanceShardPath = join(SHARD_FILES_DIR, `${instanceId}.json`);
+  let instanceShardPath = join(SHARD_FILES_DIR, `${instanceId}.json`);
+  let shardDay = currentLocalDay();
+  let rolloverPromise: Promise<void> | undefined;
+  // Failed day-close writes remain visible in memory until persisted or reload.
+  const retiredShards = new Map<string, PersistedStatsShardV7>();
   const modelApiByKey = new Map<string, string>();
   const modelNameByKey = new Map<string, string>();
   const modelEpochByKey = new Map<string, string>();
@@ -607,9 +611,14 @@ export default function (pi: ExtensionAPI) {
 
   async function refreshShardAggregate(): Promise<ShardAggregate> {
     const persistedShards = await readValidStatsShardsV7();
+    for (const shard of persistedShards) retiredShards.delete(shard.instanceId);
     const shards = persistedShards.filter((shard) => shard.instanceId !== instanceId);
+    shards.push(...retiredShards.values());
     if (currentSessionHashSet) shards.push(buildCurrentStatsShard());
+    // Keep lifetime session footer data separate from daily totals/commands.
+    // null explicitly means all retained days; undefined invokes the default day.
     const aggregate = await aggregateStatsShardsV7(shards);
+    const sessionAggregate = await aggregateStatsShardsV7(shards, null);
 
     // A reset from another process can advance epochs while this instance is
     // idle. Adopt those epochs during every aggregate refresh, not only when a
@@ -636,26 +645,19 @@ export default function (pi: ExtensionAPI) {
     }
 
     cacheStatsByModel = {};
-    for (const [sessionHash, models] of Object.entries(aggregate.bySession)) {
+    for (const [sessionHash, models] of Object.entries(sessionAggregate.bySession)) {
       for (const [key, stats] of Object.entries(models)) {
         cacheStatsByModel[`${sessionHash}:${key}`] = stats;
       }
     }
     cacheStatsTotalsByModel = aggregate.totalsByModel;
     if (currentSessionHashSet) {
-      lastActualRoutedModel = aggregate.lastRoutedModelBySession[currentSessionHash];
+      lastActualRoutedModel = sessionAggregate.lastRoutedModelBySession[currentSessionHash];
     }
     lastStatusText = undefined;
     return aggregate;
   }
 
-  async function ensureCurrentEpochs(): Promise<void> {
-    currentGlobalEpoch = await readGlobalStatsEpoch();
-    for (const key of Object.keys(cacheStatsProcessByModel)) {
-      modelEpochByKey.set(key, await readModelStatsEpoch(key));
-    }
-  }
-
   function buildCurrentStatsShard(state: "active" | "closed" = "active"): PersistedStatsShardV7 {
     const now = Date.now();
     const models: PersistedStatsShardV7["models"] = {};
@@ -683,7 +685,7 @@ export default function (pi: ExtensionAPI) {
         updatedAt: now,
         ...(state === "closed" ? { closedAt: now } : {}),
       },
-      day: currentLocalDay(),
+      day: shardDay,
       globalEpoch: currentGlobalEpoch,
       models,
       ...(lastActualRoutedModel ? { lastRoutedModel: { ...lastActualRoutedModel } } : {}),
@@ -780,9 +782,10 @@ export default function (pi: ExtensionAPI) {
 
   function persistCacheStats(ctx?: ExtensionContext, lifecycleState: "active" | "closed" = "active"): Promise<void> {
     const shard = buildCurrentStatsShard(lifecycleState);
+    const path = instanceShardPath;
     return enqueuePersist(async () => {
       try {
-        await writeStatsShardV7(instanceShardPath, shard);
+        await writeStatsShardV7(path, shard);
       } catch (error) {
         console.warn(`${LOG_PREFIX}: failed to persist cache stats shard`, error);
         if (!persistenceWarningShown) {
@@ -810,6 +813,7 @@ export default function (pi: ExtensionAPI) {
       clearTimeout(persistTimer);
       persistTimer = null;
     }
+    await rollOverStatsIfNeeded(ctx);
     // Adopt resets performed by another Pi process before capturing the shard
     // snapshot. Otherwise shutdown/command flush could rewrite stale local
     // counters under an old epoch even though aggregation already hid them.
@@ -819,27 +823,31 @@ export default function (pi: ExtensionAPI) {
   }
 
   async function rollOverStatsIfNeeded(ctx?: ExtensionContext): Promise<void> {
+    if (rolloverPromise) return rolloverPromise;
     const day = currentLocalDay();
-    let changed = false;
-    for (const key of Object.keys(cacheStatsProcessByModel)) {
-      if (cacheStatsProcessByModel[key]?.day !== day) {
-        cacheStatsProcessByModel[key] = emptyCacheStats(day);
-        changed = true;
-      }
-    }
-    for (const id of CACHE_PROVIDER_IDS) {
-      const stats = cacheStatsLegacyFamily[id];
-      if (stats && stats.day !== day) {
-        cacheStatsLegacyFamily[id] = emptyCacheStats(day);
-        changed = true;
+    if (shardDay === day) return;
+    rolloverPromise = (async () => {
+      if (persistTimer !== null) {
+        clearTimeout(persistTimer);
+        persistTimer = null;
       }
-    }
-    if (changed) {
+      // Preserve yesterday under its original UUID/day before clearing daily
+      // counters. Each day owns a new shard so total never includes yesterday.
+      await refreshShardAggregate();
+      await persistCacheStats(ctx, "closed");
+      retiredShards.set(instanceId, buildCurrentStatsShard("closed"));
+      instanceId = randomUUID();
+      instanceShardPath = join(SHARD_FILES_DIR, `${instanceId}.json`);
+      shardDay = day;
       shardCreatedAt = Date.now();
+      cacheStatsProcessByModel = {};
+      cacheStatsLegacyFamily = emptyAllCacheStats();
       lastStatusText = undefined;
-      await ensureCurrentEpochs();
-      await flushPersistCacheStats(ctx);
-    }
+      await persistCacheStats(ctx);
+      await refreshShardAggregate();
+    })();
+    try { await rolloverPromise; }
+    finally { rolloverPromise = undefined; }
   }
 
   async function restoreCacheStats(reason: string, ctx: ExtensionContext): Promise<void> {
@@ -1072,9 +1080,16 @@ export default function (pi: ExtensionAPI) {
       return {};
     }
 
+    // OpenAI Codex/Responses is unusually sensitive to skill-index shape: real
+    // TourStory task benchmarks showed the compressed Markdown index could
+    // lengthen the Pi tool trajectory enough to increase total task cost even
+    // though each request became shorter. Keep Pi's native skill block for the
+    // Codex transport; other providers retain the compression optimization.
+    const codexSkillCompressionBypass = model?.api === "openai-codex-responses";
+
     // Skill compression first, as a section edit when Pi supports it (see
     // compressSkillsViaSection); the string path below is the fallback.
-    const skillsViaSection = compressSkillsViaSection(event);
+    const skillsViaSection = codexSkillCompressionBypass ? false : compressSkillsViaSection(event);
 
     // Strip per-turn churn from <session-overview>.
     // Removing RECENT COMMITS, Working directory status, and
@@ -1088,14 +1103,18 @@ export default function (pi: ExtensionAPI) {
     // (Pi < 0.86, or a forced prompt from an earlier handler). Deterministic from the same `event.systemPromptOptions.skills`,
     // so cache stability is unchanged. No-op if opted out, below
     // SKILL_COMPRESSION_MIN_COUNT, or if pi emitted a format we don't recognize.
-    const compressedPrompt = compressSkillsInSystemPrompt(
-      strippedPrompt,
-      event.systemPromptOptions,
-    );
+    const compressedPrompt = codexSkillCompressionBypass
+      ? strippedPrompt
+      : compressSkillsInSystemPrompt(
+          strippedPrompt,
+          event.systemPromptOptions,
+        );
     // With a section edit and nothing to strip, Pi renders the compressed prompt
     // itself and no forced prompt is returned.
     recordSkillCompressionOutcome(
-      skillsViaSection
+      codexSkillCompressionBypass
+        ? { applied: false, reason: "OpenAI Codex uses Pi's native skill index to preserve task trajectory", visibleSkills, at: Date.now() }
+        : skillsViaSection
         ? { applied: "section", visibleSkills, at: Date.now() }
         : compressedPrompt !== strippedPrompt
           ? { applied: "string", visibleSkills, at: Date.now() }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cache-optimizer",
-  "version": "2.8.17",
+  "version": "2.8.19",
   "description": "Improve Pi prompt/KV cache hit rates with stable prompts, OpenAI-compatible cache keys, proxy compat warnings, and footer cache stats.",
   "keywords": [
     "pi-package",
@@ -37,8 +37,8 @@
     "check:modules": "node scripts/check-module-graph.mjs"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^1.0.0",
-    "@earendil-works/pi-server": "1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.0.2",
+    "@earendil-works/pi-server": "1.0.2",
     "@types/node": "^22.0.0",
     "jiti": "^2.7.0",
     "typescript": "^5.8.3"

package/src/stats-store.ts

@@ -26,7 +26,9 @@ export const SHARD_CLEANUP_LOCK_PATH = join(SHARD_MAINTENANCE_DIR, "cleanup.lock
 
 export const SHARD_CLEANUP_MARKER_PATH = join(SHARD_MAINTENANCE_DIR, "last-cleanup");
 
-export const SHARD_RETENTION_MS = 48 * 60 * 60 * 1000;
+// Retain closed and inactive shards for roughly two months so session-scoped
+// statistics can survive long-running conversations without meaningful disk use.
+export const SHARD_RETENTION_MS = 60 * 24 * 60 * 60 * 1000;
 
 export const SHARD_TEMP_RETENTION_MS = 24 * 60 * 60 * 1000;
 
@@ -188,6 +190,15 @@ export function mergeCacheStatsForTotal(existing: CacheStats | undefined, incomi
   return existing;
 }
 
+/** Merge counters while retaining historical days for an explicitly session-scoped view. */
+export function mergeStatsAcrossDays(existing: CacheStats | undefined, incoming: CacheStats, day: string | null): CacheStats {
+  if (day !== null) return mergeCacheStatsForTotal(existing, incoming);
+  if (!existing) return cloneCacheStats(incoming);
+  addCacheStatsTotals(existing, incoming);
+  existing.day = incoming.day > existing.day ? incoming.day : existing.day;
+  return existing;
+}
+
 export function parsePersistedRoutedModelRef(value: unknown): PersistedRoutedModelRef | undefined {
   const record = asRecord(value);
   const provider = record?.provider;
@@ -352,7 +363,7 @@ export async function readValidStatsShardsV7(directory: string = SHARD_FILES_DIR
 
 export async function aggregateStatsShardsV7(
   shards: PersistedStatsShardV7[],
-  day: string = currentLocalDay(),
+  day: string | null = currentLocalDay(),
 ): Promise<ShardAggregate> {
   const globalEpoch = await readGlobalStatsEpoch();
   const modelEpochs = new Map<string, string>();
@@ -371,7 +382,7 @@ export async function aggregateStatsShardsV7(
   const modelSessions = new Map<string, Set<string>>();
 
   for (const shard of shards) {
-    if (shard.day !== day || shard.globalEpoch !== globalEpoch) continue;
+    if ((day !== null && shard.day !== day) || shard.globalEpoch !== globalEpoch) continue;
     let contributed = false;
     if (shard.lastRoutedModel && (routedUpdatedAt.get(shard.sessionHash) ?? -1) < shard.lifecycle.updatedAt) {
       routedUpdatedAt.set(shard.sessionHash, shard.lifecycle.updatedAt);
@@ -383,11 +394,11 @@ export async function aggregateStatsShardsV7(
         epoch = await readModelStatsEpoch(key);
         modelEpochs.set(key, epoch);
       }
-      if (entry.modelEpoch !== epoch || entry.stats.day !== day) continue;
+      if (entry.modelEpoch !== epoch || (day !== null && entry.stats.day !== day)) continue;
       contributed = true;
       const sessionModels = result.bySession[shard.sessionHash] ??= {};
-      sessionModels[key] = mergeCacheStatsForTotal(sessionModels[key], entry.stats);
-      result.totalsByModel[key] = mergeCacheStatsForTotal(result.totalsByModel[key], entry.stats);
+      sessionModels[key] = mergeStatsAcrossDays(sessionModels[key], entry.stats, day);
+      result.totalsByModel[key] = mergeStatsAcrossDays(result.totalsByModel[key], entry.stats, day);
       result.instancesByModel[key] = (result.instancesByModel[key] ?? 0) + 1;
       if ((modelRefUpdatedAt.get(key) ?? -1) < shard.lifecycle.updatedAt) {
         modelRefUpdatedAt.set(key, shard.lifecycle.updatedAt);