context-doctor 0.31.1 → 0.32.0

package/README.md

@@ -1,6 +1,6 @@
 # context-doctor 🩺
 
-[![CI](https://github.com/KushalP1/context-doctor/actions/workflows/ci.yml/badge.svg)](https://github.com/KushalP1/context-doctor/actions) [![npm](https://img.shields.io/npm/v/context-doctor)](https://www.npmjs.com/package/context-doctor) [![npm downloads](https://img.shields.io/npm/dm/context-doctor)](https://www.npmjs.com/package/context-doctor) [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-io.github.KushalP1%2Fcontext--doctor-blue)](https://registry.modelcontextprotocol.io) [![license: MIT](https://img.shields.io/badge/license-MIT-blue)](./LICENSE) ![macOS | Linux | Windows](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-lightgrey)
+[![CI](https://github.com/KushalP1/context-doctor/actions/workflows/ci.yml/badge.svg)](https://github.com/KushalP1/context-doctor/actions) [![npm](https://img.shields.io/npm/v/context-doctor)](https://www.npmjs.com/package/context-doctor) [![npm downloads](https://img.shields.io/npm/dm/context-doctor)](https://www.npmjs.com/package/context-doctor) [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-io.github.KushalP1%2Fcontext--doctor-blue)](https://registry.modelcontextprotocol.io) [![AgentHub 已收录：context-doctor](https://myagenthub.cn/badge/io.github.KushalP1/context-doctor)](https://myagenthub.cn/p/io.github.KushalP1/context-doctor) [![license: MIT](https://img.shields.io/badge/license-MIT-blue)](./LICENSE) ![macOS | Linux | Windows](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-lightgrey)
 
 **See where your AI agent's tokens go, and stop paying for the ones that do nothing.**
 
@@ -54,9 +54,9 @@ Pick where you work. Each takes about a minute and is fully reversible.
 
 On the author's own Claude Code history (mostly Opus and Fable models with the 1M window, priced at API list prices; `savings` computes yours the same way):
 
-- **Compacting when you come back after the cache expired:** 401 such returns in 133 days; compacting then would have saved **$4,053 net, about $914 a month**. [Details →](#what-it-saves)
-- **A 400k auto-compact window instead of ~970k:** **55% less input cost** over 30 days ($6,119 to $2,757), for 15 compactions a week instead of 5. [The trade-off →](#3-compacting-earlier-automatic)
-- **Autopilot:** **9.8% less input cost, no session made more expensive.**
+- **Compacting when you come back after the cache expired:** 479 such returns in 133 days; compacting then would have saved **$2,993 net, about $675 a month**. [Details →](#what-it-saves)
+- **A 400k auto-compact window instead of ~970k:** **50% less input cost** over 30 days ($3,648 to $1,814), for 14 compactions a week instead of 5. [The trade-off →](#3-compacting-earlier-automatic)
+- **Autopilot:** **12.7% less input cost, no session made more expensive.**
 - **pack:** 9 of 10 questions about this repository answered from **0.6% of its tokens**. [How →](#before-it-enters-the-context-pack-and-overhead)
 - **Counting Claude correctly:** current Claude models pack 2.75 characters per token, not the 4 most tools assume, so estimates built on 4 undercount Claude by about 40%. `context-doctor accuracy` re-checks the ratio on your own sessions.
 
@@ -86,39 +86,38 @@ Findings (4)
 
 ## What it saves
 
-Measured, not modelled, on every Claude Code session on the author's machine (mostly Opus 5 and Fable 5 with the 1M window), priced the way the prompt cache bills it (cached reads 0.1x, writes 1.25x) at API list prices. `context-doctor savings` runs the same measurement on yours.
+Measured, not modelled, on every Claude Code session on the author's machine (mostly Opus 5 and Fable 5 with the 1M window), priced the way the prompt cache bills it (cached reads at each model's read rate, 2.5-10% of input; writes 1.25x input for the 5-minute cache, 2x for the hour) at API list prices. Re-measured on 2026-10-13 with each request at its own model and current prices (Opus 5.5 is $4 per million input tokens with $0.20 reads). `context-doctor savings` runs the same measurement on yours.
 
-**1. Compacting when you come back** (every Claude Code surface, desktop app included). 133 days, 401 returns to a session over 150k tokens after more than 65 idle minutes; median context at the return, 517k tokens.
+**1. Compacting when you come back** (every Claude Code surface, desktop app included). 133 days, 479 returns to a session over 150k tokens after its prompt cache expired (65 idle minutes on the 1-hour cache, 10 on the 5-minute one that Claude Code 2.1.295 often writes); median context at the return, 522k tokens.
 
 | | |
 |---|---|
-| Net saving had you run `/compact` after the first reply | **$4,053 (about $914 a month)** |
-| Returns where it paid off | 296 of 401 |
-| Worst single case | −$2.30 (a session left a few messages later) |
+| Net saving had you run `/compact` after the first reply | **$2,993 (about $675 a month)** |
+| Returns where it paid off | 342 of 479 |
+| Worst single case | −$1.79 (a session left a few messages later) |
 
 Each return counts only the messages up to the next return, and the compaction request is charged as a cost. Not counted: files the model may re-read after compacting, and what the summary leaves out. That is why this is advice with the numbers attached, not something done for you.
 
-**2. Autopilot** (terminal and IDE sessions, API apps). 130 days, 43 sessions, replayed through the shipped autopilot code with real timestamps:
+**2. Autopilot** (terminal and IDE sessions, API apps). 133 days, 67 sessions, replayed through the shipped autopilot code with real timestamps:
 
 | | Without autopilot | With autopilot | Saved |
 |---|---|---|---|
-| Input tokens sent | 41.4 billion | 37.6 billion | **3.8 billion (9.2%)** |
-| Input cost at API list price | $48,962 | $44,268 | **$4,694 (9.8%)** |
-| Sessions made more expensive | | | **0 of 43** |
+| Input cost at API list price | $11,347 | $9,905 | **$1,442 (12.7%)** |
+| Sessions made more expensive | | | **0 of 67** |
 
-The median session saves 1.9%, the best 37.7%: long sessions are where the money is (94% of input cost on that machine came from requests above 200k tokens). These sessions ran in the desktop app, which autopilot cannot reach, so for the author this is what the same sessions would have saved in a terminal; `context-doctor savings` separates the two for you.
+30 of 67 sessions save something, the best 34.9%: long sessions that go idle are where the money is. These sessions ran in the desktop app, which autopilot cannot reach, so for the author this is what the same sessions would have saved in a terminal; `context-doctor savings` separates the two for you.
 
 **3. Compacting earlier** <a id="3-compacting-earlier-automatic"></a>(automatic, every Claude Code surface, desktop app included). The offer in 1 is advice, and on the author's machine it was followed 1 time in 33. Claude Code has a native setting that needs nobody to follow anything: `autoCompactWindow` in `~/.claude/settings.json` makes it compact as if the window were that size. `context-doctor compact-window` replays each session request by request at several sizes, priced as the cache bills (each simulated compaction pays its own request and a 20k-token summary at the output rate), and changes nothing until you pick one:
 
 | Window | Input cost, last 30 days | Saved | Compactions a week |
 |---|---|---|---|
-| as now (~970k) | $6,119 | | 5.1 |
-| 600k | $3,570 | $2,549 (42%) | 6.5 |
-| **400k** | **$2,757** | **$3,362 (55%)** | **14.7** |
-| 300k | $2,353 | $3,766 (62%) | 24.5 |
-| 200k | $1,963 | $4,155 (68%) | 46.9 |
+| as now (~970k) | $3,648 | | 4.7 |
+| 600k | $2,242 | $1,405 (39%) | 6.5 |
+| **400k** | **$1,814** | **$1,833 (50%)** | **14.2** |
+| 300k | $1,664 | $1,983 (54%) | 25.2 |
+| 200k | $1,501 | $2,146 (59%) | 48.1 |
 
-29 sessions. The replay's baseline came within 9% of what the transcripts say was billed, on the low side. The cost is real: each compaction replaces the session's history with a summary, so a smaller window trades detail for money. That is why the command shows the table first and sets a window only when you name one (`context-doctor compact-window 400k`; `off` undoes it, and a backup of settings.json is kept).
+41 sessions. The cost is real: each compaction replaces the session's history with a summary, so a smaller window trades detail for money. That is why the command shows the table first and sets a window only when you name one (`context-doctor compact-window 400k`; `off` undoes it, and a backup of settings.json is kept).
 
 On a Claude subscription you do not pay list price; the same tokens come out of your usage limit instead. Anthropic does not publish how limits weight cached tokens, so read the dollars as the size of the effect, not as your bill.
 
@@ -180,6 +179,7 @@ MCP servers are part of the same overhead: each one's tool definitions ride on e
 
 ## What's new
 
+- **0.32 A full audit, fixed**: five reviewers read every module against real data; each finding was reproduced, fixed and tested (list in [ROADMAP.md](./ROADMAP.md#fixed-by-a-local-audit-2026-10-13)). The ones that mattered most: `npx context-doctor install` wrote an MCP launcher for a package that does not exist; `uninstall` left Claude Code pointed at a dead proxy port; the optimizer could move one parallel tool result under another's id and drop the note beside them; autopilot could clear output the model had not read; edited histories now respect thinking-block signatures; current prices (Opus 5.5 $4, Sonnet 5.x $2, Haiku 5.5 $0.10) and 1-hour cache writes at 2x; replies counted once and `--days` applied per request. The cold-resume offer follows the cache lifetime a session writes. The figures above were re-measured with it.
 - **0.31 Save tokens without losing quality**: a PreCompact hook makes every Claude Code compaction keep the session's changed files, open tasks, your instructions and still-failing tests; `context-doctor compactions` measures re-reads, tool errors and corrections before and after each compaction on your history; `compact-window` now charges the re-reads to every compaction it simulates.
 - **0.30 Where the money goes, and a self-healing service**: `context-doctor subagents` compares each subagent's bill with the same work done in the parent session; `cache-plan` places Anthropic `cache_control` breakpoints in an API request and prices them. Fixes from a local audit: the autopilot service now restarts itself onto a newly installed version, `doctor` no longer writes fake hook checks into the activity ledger, and `<synthetic>` placeholder messages no longer hide a session's model.
 - **0.29 Python, and where the work goes**: a dependency-free Python package (`python/`) with `pack_documents` for LangChain and LlamaIndex results, `pack_context`, `estimate_tokens` and `profile_messages`, held byte for byte to the TypeScript by parity tests. `context-doctor reads` shows the files read into session after session; `context-doctor tasks` shows cost per commit per project, from your own transcripts.
@@ -258,7 +258,7 @@ Practical upshot: a developer who only wants cheaper, faster API calls never tou
 | `context-doctor savings [--days n] [--share [--copy]]` | What your recent Claude Code sessions cost, and what `/compact` at cold resumes, autopilot and an earlier auto-compact window would save, replayed through the shipped code against your actual billed usage. `--share` prints totals only (no project names or paths) to post. A bare `context-doctor` in a terminal shows the same |
 | `context-doctor compact-window [status\|off\|<size>]` | Replay your last 30 days at auto-compact windows from 200k to 800k: input cost, saving, and how many more compactions each means. `400k` (or `250000`, `0.4m`) sets Claude Code's `autoCompactWindow`, with a backup; `off` removes it. Works in every Claude Code surface, the desktop app included |
 | `context-doctor mcp [--http]` | The MCP server as a subcommand, for clients and registries that launch `npx -y context-doctor mcp` |
-| `context-doctor autopilot on\|off\|pause\|resume\|status` | Every new Claude Code session goes through the local proxy, which clears stale tool output only when the prompt cache is cold: measured 9.8% less input cost, no session worse |
+| `context-doctor autopilot on\|off\|pause\|resume\|status` | Every new Claude Code session goes through the local proxy, which clears stale tool output only when the prompt cache is cold: measured 12.7% less input cost, no session worse |
 | `context-doctor instructions [--copy]` | The ~180-token standing rules (~120 on GPT) for claude.ai / ChatGPT preferences, for web and phones where no server runs |
 | `context-doctor pack <files\|dirs\|-> --query "…"` | Only the chunks of big documents, logs or code a question needs, ranked and fit to `--max-tokens` (default 4000). No query: an outline; `--ids a#2,b#5` picks chunks from it. Offline, no key |
 | `context-doctor overhead [--days n] [--mcp]` | What every request re-reads before your message: measured first-request size (Claude Code, Codex and Gemini CLI sessions), each memory file (CLAUDE.md and imports, rules, auto memory, AGENTS.md, Cursor rules, GEMINI.md) priced per month, MCP calls per server; `--mcp` sizes each configured server's tool definitions and flags unused ones |
@@ -335,7 +335,7 @@ context-doctor autopilot off       # remove it
 
 **What it does to each request:** once old tool output adds up to 20k+ tokens (file reads, shell output, search and web results, screenshots inside them), it replaces that output with a one-line note, keeping the 3 most recent results. The tool call stays in the history, so the model can simply run it again if it needs the output. Your messages, its answers, answers you gave to its questions, subagent reports and MCP results are never touched.
 
-**Why it cannot make a session more expensive.** A prompt cache matches a byte-identical prefix, and changing old history re-bills everything after the change at the write rate (1.25x instead of 0.1x). So autopilot changes history only when the cache is cold anyway: after an idle gap longer than the cache lifetime the request itself declares (1 hour for Claude Code on a subscription, 5 minutes otherwise), when the whole prompt is re-written regardless. Once cleared, an output stays cleared on every later request, so the prefix is identical between clearings and the cache keeps hitting.
+**Why it cannot make a session more expensive.** A prompt cache matches a byte-identical prefix, and changing old history re-bills everything after the change at the write rate (1.25x or 2x input instead of a read's 2.5-10%). So autopilot changes history only when the cache is cold anyway: after an idle gap longer than the cache lifetime the request itself declares (1 hour for Claude Code on a subscription, 5 minutes otherwise), when the whole prompt is re-written regardless. Once cleared, an output stays cleared on every later request, so the prefix is identical between clearings and the cache keeps hitting. Output the model has not read yet is never cleared. On current Claude models a thinking block is bound to the history before it, and accounts created on or after 2026-08-31 get an error for an edited history; when that happens the proxy resends the request unedited and stops editing that account's histories where thinking follows.
 
 **Measured before it shipped**, by replaying every Claude Code session on the author's machine (43 sessions, 130 days) request by request through the shipped code, priced as the cache bills it, with real timestamps: 3.8 billion input tokens not sent and $4,694 at list price, ~$1,080 a month ([details](#what-it-saves)). `scripts/replay-autopilot.mjs` does this on yours:
 
@@ -345,7 +345,7 @@ context-doctor autopilot off       # remove it
 | Also clear on a warm cache when the saving "should" repay the rewrite | 9.9% | −0.13% (one session worse) |
 | The proxy's general strategies (dedupe, trim, strip-base64) | 6.7% | −13% (one session worse) |
 
-94% of input cost on that machine came from requests above 200k tokens, which is where the clearing lands. Smaller requests also mean later auto-compaction and a faster first token.
+Re-measured on 2026-10-13 with current prices, each request at its own model and the audit's fixes (output the model has not read is never cleared, a conversation the proxy has not seen counts as warm): 67 sessions over 133 days, $1,442 of $11,347 at list price (12.7%), no session worse. 94% of input cost on that machine came from requests above 200k tokens, which is where the clearing lands. Smaller requests also mean later auto-compaction and a faster first token.
 
 **Never in the way:** anything it cannot parse is forwarded unchanged; only Anthropic `/v1/messages` requests are touched. It adds about 7 ms to a 2.9 MB (~1M token) request. If the proxy dies, the service restarts it within seconds, and the every-prompt hook checks it before each prompt and starts it if needed (measured: 0.6 s once, when it had to). `pause` turns it into a passthrough without restarting anything; `off` removes the setting before stopping the service, and sessions started while it was on need a restart.
 
@@ -431,7 +431,7 @@ For any other MCP client, the server entry is:
   "mcpServers": {
     "context-doctor": {
       "command": "npx",
-      "args": ["-y", "context-doctor-mcp"]
+      "args": ["-y", "context-doctor", "mcp"]
     }
   }
 }
@@ -768,7 +768,7 @@ For the editor extension: bump `vscode/package.json`, add a `vscode/CHANGELOG.md
 
 Locally, `npm run build:mcpb` builds the bundle (`MCPB_SELF_SIGNED=1` exercises the signing path with a throwaway certificate; Desktop still warns for those).
 
-**What the npm download number measures.** `install` writes `npx -y context-doctor-mcp` into MCP configs, and npx re-fetches the tarball whenever a new version exists. So every release is downloaded once by every active install within about a day, and the daily count is almost entirely those refreshes: on this package, release days run ~170 downloads and non-release days ~27. Read it as "size of the active installed base × number of releases", not as new users — a quiet week with no releases will look like a decline while nothing has changed. Two corollaries: the release-day figure is a live count of machines running context-doctor, and a broken release reaches all of them automatically, which is why `prepublishOnly` runs the full test suite. npm's stats also lag by several days and occasionally record a day as zero; a zero on a release day is a gap in their pipeline, not in usage.
+**What the npm download number measures.** `install` run through npx writes `npx -y context-doctor mcp` into MCP configs, and npx re-fetches the tarball whenever a new version exists. So every release is downloaded once by every active install within about a day, and the daily count is almost entirely those refreshes: on this package, release days run ~170 downloads and non-release days ~27. Read it as "size of the active installed base × number of releases", not as new users — a quiet week with no releases will look like a decline while nothing has changed. Two corollaries: the release-day figure is a live count of machines running context-doctor, and a broken release reaches all of them automatically, which is why `prepublishOnly` runs the full test suite. npm's stats also lag by several days and occasionally record a day as zero; a zero on a release day is a gap in their pipeline, not in usage.
 
 Known gotcha: if `npm publish` fails with **`404 Not Found - PUT …/context-doctor`** on a package that clearly exists, the real cause is an **expired npm login token** — npm reports unauthenticated publishes as a 404, not a 401. Check with `npm whoami`; if that errors, run `npm login` and publish again.
 

package/dist/autoclear.d.ts

@@ -51,13 +51,21 @@ export interface AutoClearOptions {
      * warm clearing off, cold cache only (the never-worse setting).
      */
     paybackSafety?: number;
-    /** Where cleared ids persist so a restart does not un-clear (and re-bill) them. */
+    /**
+     * Where cleared ids persist so a restart does not un-clear (and re-bill)
+     * them, with each conversation's last request time so a restart does not
+     * mistake a warm cache for a cold one.
+     */
     statePath?: string;
     /**
-     * Treat a conversation this instance has never seen as warm-cached (so
-     * nothing is cleared on it). The proxy sees every request and leaves this
-     * off; an in-process wrapper in a fresh process cannot know whether another
-     * process just sent the conversation, so it turns this on.
+     * Treat a conversation this instance has no record of as warm-cached (so
+     * nothing is cleared on it). Both the proxy and the in-process wrapper turn
+     * this on: a wrapper in a fresh process cannot know whether another process
+     * just sent the conversation, and a restarted proxy cannot know either
+     * unless the conversation's last request time was persisted (statePath).
+     * Calling a warm cache cold pays a full rewrite; calling a cold one warm
+     * only delays a free clearing to the next idle gap. Off here so a bare
+     * AutoClearer (the savings replay) keeps its first-request-is-cold model.
      */
     unseenIsWarm?: boolean;
 }
@@ -71,7 +79,26 @@ export interface AutoClearResult {
     reason: string;
     /** Index of the first message rewritten on this request (the cache breaks from here), or -1. */
     firstChanged: number;
+    /** Ids this request cleared for the first time. */
+    newIds: string[];
+    /** Every id whose clearing this request carries, earlier batches included. */
+    appliedIds: string[];
 }
+/**
+ * Whether a thinking block comes at or after message `index`. On current
+ * Claude models (Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5) a thinking
+ * block's signature binds the conversation before it: an edit to an earlier
+ * message invalidates every later thinking block, and accounts created on or
+ * after 2026-08-31 get a 400 for it ("... bound to a different
+ * conversation"), on every retry of the same body.
+ */
+export declare function thinkingAfter(messages: unknown[], index: number): boolean;
+/**
+ * A request that sets thinking.block_binding has opted into that check (any
+ * value, "drop_block" included, which silently drops the reasoning an edit
+ * invalidates), so it is treated like an account known to enforce it.
+ */
+export declare function optsIntoThinkingCheck(body: Record<string, unknown>): boolean;
 interface Found {
     /** Index of the message / input item that holds the result (cache breaks from here). */
     unit: number;
@@ -93,7 +120,12 @@ interface View {
     toolName: Map<string, string>;
     results: Array<Omit<Found, "tokens">>;
     firstUser: unknown;
-    firstToolId: string;
+    /**
+     * Index of the last unit the model wrote (-1 for none). Results after it
+     * arrive with this request: the model has not read them yet, so they are
+     * never eligible, however many there are (six parallel reads).
+     */
+    seenUpTo: number;
     ttlMs: number;
 }
 export declare function clearedNote(tokens: number): string;
@@ -114,12 +146,19 @@ export declare class AutoClearer {
     private convs;
     private opts;
     private dirty;
+    /** Conversation times changed since the last save (written at most every CONV_SAVE_MS, or on flush). */
+    private convsDirty;
+    private lastSave;
+    /** Accounts (salted credential hashes from the caller) whose API rejected a history autopilot edited. */
+    private rejecting;
     constructor(options?: AutoClearOptions);
     /**
      * Rewrite `body` in place: an Anthropic Messages, OpenAI Chat Completions or
      * OpenAI Responses request. Never throws; anything unrecognised is left alone.
+     * `account` names the credential the request carries (the proxy passes a
+     * salted hash), for accounts whose API rejects edited history.
      */
-    apply(body: Record<string, unknown>, now?: number, modelHint?: string): AutoClearResult;
+    apply(body: Record<string, unknown>, now?: number, modelHint?: string, account?: string): AutoClearResult;
     /**
      * Warm cache: clearing rewrites everything after the first cleared result
      * at the write rate (1.25x instead of 0.1x: 1.15x extra, once), and saves
@@ -129,6 +168,18 @@ export declare class AutoClearer {
      * cover the rewrite `paybackSafety` times over.
      */
     private shouldClearWarm;
+    /** Write pending state now (the proxy calls this on a timer and before it exits). */
+    flush(): void;
+    /** Whether this account's API has rejected a history autopilot edited (see thinkingAfter). */
+    rejectsEdits(account?: string): boolean;
+    /** Remember, across restarts, that this account's API rejects edited history. */
+    noteEditsRejected(account: string): void;
+    /**
+     * Stop applying these clearings: the API refused the request that carried
+     * them, and any thinking it produces from now on is bound to the history
+     * without them.
+     */
+    forget(ids: string[]): void;
     private load;
     private save;
 }

package/dist/autoclear.js

@@ -55,7 +55,44 @@ export const CLEARABLE_TOOLS = new Set([
 ]);
 /** Tokens billed for one image inside a tool result (a full-size screenshot is ~1.6k on Claude). */
 const IMAGE_TOKENS = 1600;
+/**
+ * Whether a thinking block comes at or after message `index`. On current
+ * Claude models (Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5) a thinking
+ * block's signature binds the conversation before it: an edit to an earlier
+ * message invalidates every later thinking block, and accounts created on or
+ * after 2026-08-31 get a 400 for it ("... bound to a different
+ * conversation"), on every retry of the same body.
+ */
+export function thinkingAfter(messages, index) {
+    for (let i = Math.max(0, index); i < messages.length; i++) {
+        const content = messages[i]?.content;
+        if (Array.isArray(content) && content.some((b) => b?.type === "thinking" || b?.type === "redacted_thinking"))
+            return true;
+    }
+    return false;
+}
+/**
+ * A request that sets thinking.block_binding has opted into that check (any
+ * value, "drop_block" included, which silently drops the reasoning an edit
+ * invalidates), so it is treated like an account known to enforce it.
+ */
+export function optsIntoThinkingCheck(body) {
+    const thinking = body.thinking;
+    return Boolean(thinking && typeof thinking === "object" && thinking.block_binding !== undefined);
+}
 const HOUR = 3_600_000;
+/**
+ * Conversations' last request times are written at most this often (and on
+ * flush). A record read back after a crash can be this much older than the
+ * truth, so it is read as this much newer: when unsure, warm.
+ */
+const CONV_SAVE_MS = 60_000;
+function lastIndex(items, pred) {
+    for (let i = items.length - 1; i >= 0; i--)
+        if (pred(items[i]))
+            return i;
+    return -1;
+}
 export function clearedNote(tokens) {
     // Not "run it again": a cleared Bash result may come from a command with
     // side effects (a push, a delete), and repeating that would be wrong.
@@ -101,11 +138,13 @@ function isOpenAIChat(messages) {
 export function viewOf(body) {
     const toolName = new Map();
     const results = [];
-    let firstToolId = "";
     // Gemini generateContent: contents[].parts[] with functionCall / functionResponse.
-    // Ids are optional there, so a missing one is derived from its position
-    // (stable: history only grows) and scoped to the conversation, because the
-    // cleared set is keyed by id and positions repeat across conversations.
+    // Ids are optional there, so a missing one is derived. Position and the
+    // first user message alone repeat whenever the same prompt runs twice, and
+    // the cleared set is keyed by id: run 2 then had run 1's clearings applied
+    // to its own results, newest included. The response's own content is part
+    // of the derived id, so another run's result is another id unless it is
+    // byte-identical at the same place (and apply() still requires it eligible).
     if (Array.isArray(body.contents)) {
         const units = body.contents;
         const firstUser = units.find((u) => u?.role === "user")?.parts;
@@ -118,12 +157,12 @@ export function viewOf(body) {
                 const call = p?.functionCall;
                 const resp = p?.functionResponse;
                 if (call && typeof call === "object") {
-                    const id = typeof call.id === "string" && call.id ? call.id : `gemini:${scope}:${i}:${j}`;
-                    toolName.set(id, String(call.name ?? ""));
-                    firstToolId ||= id;
+                    if (typeof call.id === "string" && call.id)
+                        toolName.set(call.id, String(call.name ?? ""));
                 }
                 else if (resp && typeof resp === "object") {
-                    const id = typeof resp.id === "string" && resp.id ? resp.id : `gemini:${scope}:${i}:${j}`;
+                    const content = createHash("sha1").update(JSON.stringify(resp.response ?? "")).digest("hex").slice(0, 12);
+                    const id = typeof resp.id === "string" && resp.id ? resp.id : `gemini:${scope}:${i}:${j}:${content}`;
                     // The response names its tool, so it classifies on its own.
                     if (!toolName.has(id))
                         toolName.set(id, String(resp.name ?? ""));
@@ -131,7 +170,8 @@ export function viewOf(body) {
                 }
             });
         });
-        return { format: "gemini", units, toolName, results, firstUser, firstToolId, ttlMs: requestTtlMs(body) };
+        const seenUpTo = lastIndex(units, (u) => u?.role === "model");
+        return { format: "gemini", units, toolName, results, firstUser, seenUpTo, ttlMs: requestTtlMs(body) };
     }
     if (Array.isArray(body.input)) {
         const units = body.input;
@@ -139,19 +179,23 @@ export function viewOf(body) {
             const t = it?.type;
             if ((t === "function_call" || t === "custom_tool_call" || t === "local_shell_call") && typeof it.call_id === "string") {
                 toolName.set(it.call_id, t === "local_shell_call" ? "shell" : String(it.name ?? ""));
-                firstToolId ||= it.call_id;
             }
             else if ((t === "function_call_output" || t === "custom_tool_call_output" || t === "local_shell_call_output") && typeof it.call_id === "string") {
                 results.push({ unit: i, id: it.call_id, content: it.output, set: (note) => { units[i] = { ...it, output: note }; } });
             }
         });
         const firstUser = units.find((u) => u?.role === "user")?.content;
-        return { format: "openai-responses", units, toolName, results, firstUser, firstToolId, ttlMs: requestTtlMs(body) };
+        // Model-written items: its tool calls, reasoning and assistant messages.
+        // With previous_response_id the input holds none of them, so every result
+        // in it is new to the model.
+        const seenUpTo = lastIndex(units, (u) => u?.role === "assistant" || ["function_call", "custom_tool_call", "local_shell_call", "reasoning"].includes(String(u?.type)));
+        return { format: "openai-responses", units, toolName, results, firstUser, seenUpTo, ttlMs: requestTtlMs(body) };
     }
     const messages = body.messages;
     if (!Array.isArray(messages) || messages.length === 0)
         return undefined;
     const firstUser = messages.find((m) => m?.role === "user")?.content;
+    const seenUpTo = lastIndex(messages, (m) => m?.role === "assistant");
     if (isOpenAIChat(messages)) {
         messages.forEach((m, i) => {
             if (m?.role === "assistant" && Array.isArray(m.tool_calls)) {
@@ -159,14 +203,13 @@ export function viewOf(body) {
                     if (typeof c?.id !== "string")
                         continue;
                     toolName.set(c.id, String(c.function?.name ?? c.name ?? ""));
-                    firstToolId ||= c.id;
                 }
             }
             else if (m?.role === "tool" && typeof m.tool_call_id === "string") {
                 results.push({ unit: i, id: m.tool_call_id, content: m.content, set: (note) => { messages[i] = { ...m, content: note }; } });
             }
         });
-        return { format: "openai-chat", units: messages, toolName, results, firstUser, firstToolId, ttlMs: requestTtlMs(body) };
+        return { format: "openai-chat", units: messages, toolName, results, firstUser, seenUpTo, ttlMs: requestTtlMs(body) };
     }
     messages.forEach((m, i) => {
         if (!Array.isArray(m?.content))
@@ -175,25 +218,36 @@ export function viewOf(body) {
         blocks.forEach((b, j) => {
             if (m.role === "assistant" && b?.type === "tool_use" && typeof b.id === "string") {
                 toolName.set(b.id, String(b.name ?? ""));
-                firstToolId ||= b.id;
             }
             else if (m.role === "user" && b?.type === "tool_result" && typeof b.tool_use_id === "string") {
                 results.push({ unit: i, id: b.tool_use_id, content: b.content, set: (note) => { blocks[j] = { ...b, content: note }; } });
             }
         });
     });
-    return { format: "anthropic", units: messages, toolName, results, firstUser, firstToolId, ttlMs: requestTtlMs(body) };
+    return { format: "anthropic", units: messages, toolName, results, firstUser, seenUpTo, ttlMs: requestTtlMs(body) };
 }
 /**
- * A conversation's identity: its first user message plus its first tool call
- * id. The message alone can repeat across sessions (the same project context
- * opens every session in a folder); tool call ids are unique per session.
+ * A conversation's identity, the same from its first request on: the first
+ * user message, plus the client's own session tag when it sends one
+ * (Anthropic metadata.user_id, which Claude Code fills per session; OpenAI
+ * prompt_cache_key). The first user message is read without cache_control:
+ * Claude Code marks the last message, which on request 1 is the first one,
+ * and moves the marker on request 2. Through 0.31.1 the key also held the
+ * first tool call id, so request 2 (the first tool round) was a new,
+ * never-seen conversation, called cold eight seconds after request 1.
+ * Two sessions that open with the same message and send no tag share a key;
+ * that only ever makes one look warm when the other is, the safe direction.
  * The model is left out on purpose: switching models mid-session keeps the
  * conversation (and the cleared set) but not the cache, which the TTL check
  * cannot see, so a model switch is treated as warm, the safe direction.
  */
-function conversationKey(view) {
-    return createHash("sha1").update(JSON.stringify(view.firstUser ?? "").slice(0, 4000)).update(view.firstToolId).digest("hex");
+function conversationKey(view, body) {
+    const first = JSON.stringify(view.firstUser ?? "", (k, v) => (k === "cache_control" ? undefined : v)) ?? "";
+    const h = createHash("sha1").update(first.slice(0, 4000));
+    const tag = body.metadata?.user_id ?? body.prompt_cache_key;
+    if (typeof tag === "string")
+        h.update("\0").update(tag);
+    return h.digest("hex");
 }
 export class AutoClearer {
     cleared = new Map();
@@ -202,6 +256,11 @@ export class AutoClearer {
     convs = new Map();
     opts;
     dirty = false;
+    /** Conversation times changed since the last save (written at most every CONV_SAVE_MS, or on flush). */
+    convsDirty = false;
+    lastSave = 0;
+    /** Accounts (salted credential hashes from the caller) whose API rejected a history autopilot edited. */
+    rejecting = new Set();
     constructor(options = {}) {
         this.opts = {
             keepRecent: options.keepRecent ?? 3,
@@ -215,21 +274,26 @@ export class AutoClearer {
     /**
      * Rewrite `body` in place: an Anthropic Messages, OpenAI Chat Completions or
      * OpenAI Responses request. Never throws; anything unrecognised is left alone.
+     * `account` names the credential the request carries (the proxy passes a
+     * salted hash), for accounts whose API rejects edited history.
      */
-    apply(body, now = Date.now(), modelHint) {
-        const none = (reason, cold = false) => ({ changed: false, newlyCleared: 0, tokensRemoved: 0, cold, reason, firstChanged: -1 });
+    apply(body, now = Date.now(), modelHint, account) {
+        const none = (reason, cold = false) => ({ changed: false, newlyCleared: 0, tokensRemoved: 0, cold, reason, firstChanged: -1, newIds: [], appliedIds: [] });
         try {
             const view = viewOf(body);
             if (!view)
                 return none("no messages");
             // Gemini puts the model in the URL, not the body; the proxy passes it.
             const model = typeof body.model === "string" ? body.model : modelHint;
-            const key = conversationKey(view);
+            const key = conversationKey(view, body);
             const conv = this.convs.get(key);
             const cold = conv ? now - conv.last > view.ttlMs : !this.opts.unseenIsWarm;
+            // Delete first so the map stays in last-used order and the cap evicts idle conversations.
+            this.convs.delete(key);
             this.convs.set(key, { last: now, requests: (conv?.requests ?? 0) + 1 });
             if (this.convs.size > 2000)
                 this.convs.delete(this.convs.keys().next().value);
+            this.convsDirty = true;
             const results = view.results.map((r) => {
                 let tokens = this.sizes.get(r.id);
                 if (tokens === undefined) {
@@ -240,8 +304,11 @@ export class AutoClearer {
                 }
                 return { ...r, tokens };
             });
+            // Results that arrive with this request (after the model's last turn)
+            // are not eligible however many there are: the model has not read them.
             const eligible = results.slice(0, Math.max(0, results.length - this.opts.keepRecent))
-                .filter((r) => CLEARABLE_TOOLS.has(view.toolName.get(r.id) ?? ""));
+                .filter((r) => r.unit <= view.seenUpTo && CLEARABLE_TOOLS.has(view.toolName.get(r.id) ?? ""));
+            const eligibleIds = new Set(eligible.map((r) => r.id));
             const pending = eligible.filter((r) => !this.cleared.has(r.id) && r.tokens > 200);
             const pendingTokens = pending.reduce((n, r) => n + r.tokens, 0);
             let reason = "nothing to clear";
@@ -262,17 +329,29 @@ export class AutoClearer {
             else if (pendingTokens > 0) {
                 reason = `waiting for a ${Math.round(this.opts.minClearTokens / 1000)}k batch`;
             }
+            // An account that rejects edited history gets no NEW clearing a
+            // thinking block comes after: that block is bound to the history as it
+            // was. Clearings already sent keep being applied, because thinking
+            // generated since then is bound to the cleared history; dropping them
+            // would break the conversation the other way.
+            if (taken.length && (this.rejectsEdits(account) || optsIntoThinkingCheck(body)) && thinkingAfter(view.units, Math.min(...taken.map((r) => r.unit)))) {
+                taken = [];
+                reason = "thinking blocks follow the stale output and this account rejects edited history: left as is";
+            }
             for (const r of taken)
                 this.cleared.set(r.id, r.tokens);
             if (taken.length)
                 this.dirty = true;
             // Apply every clearing ever decided for this conversation, so the
-            // prefix is identical to what was sent last time.
+            // prefix is identical to what was sent last time. A remembered id must
+            // still be eligible here: a derived id (Gemini without ids) can recur in
+            // another conversation, where it must not cost that one its newest result.
             let removed = 0;
             let changed = false;
             let firstChanged = -1;
+            const appliedIds = [];
             for (const r of results) {
-                if (!this.cleared.has(r.id))
+                if (!this.cleared.has(r.id) || !eligibleIds.has(r.id))
                     continue;
                 const note = clearedNote(this.cleared.get(r.id));
                 if (r.content === note)
@@ -280,11 +359,12 @@ export class AutoClearer {
                 removed += Math.max(0, r.tokens - estimateTokens(note, model));
                 r.set(note);
                 changed = true;
+                appliedIds.push(r.id);
                 if (firstChanged === -1 || r.unit < firstChanged)
                     firstChanged = r.unit;
             }
             this.save();
-            return { changed, newlyCleared: taken.length, tokensRemoved: removed, cold, reason, firstChanged };
+            return { changed, newlyCleared: taken.length, tokensRemoved: removed, cold, reason, firstChanged, newIds: taken.map((r) => r.id), appliedIds };
         }
         catch {
             return none("error: request forwarded unchanged");
@@ -307,6 +387,36 @@ export class AutoClearer {
         const saving = 0.1 * pendingTokens * requestsSoFar;
         return saving >= this.opts.paybackSafety * rewriteCost;
     }
+    /** Write pending state now (the proxy calls this on a timer and before it exits). */
+    flush() {
+        this.save(true);
+    }
+    /** Whether this account's API has rejected a history autopilot edited (see thinkingAfter). */
+    rejectsEdits(account) {
+        return account !== undefined && this.rejecting.has(account);
+    }
+    /** Remember, across restarts, that this account's API rejects edited history. */
+    noteEditsRejected(account) {
+        if (this.rejecting.has(account))
+            return;
+        this.rejecting.add(account);
+        this.dirty = true;
+        this.save();
+    }
+    /**
+     * Stop applying these clearings: the API refused the request that carried
+     * them, and any thinking it produces from now on is bound to the history
+     * without them.
+     */
+    forget(ids) {
+        let any = false;
+        for (const id of ids)
+            any = this.cleared.delete(id) || any;
+        if (any) {
+            this.dirty = true;
+            this.save();
+        }
+    }
     load() {
         if (!this.opts.statePath || !existsSync(this.opts.statePath))
             return;
@@ -314,20 +424,35 @@ export class AutoClearer {
             const data = JSON.parse(readFileSync(this.opts.statePath, "utf8"));
             for (const [id, tokens] of data.cleared ?? [])
                 this.cleared.set(id, tokens);
+            for (const account of data.rejectsEdits ?? [])
+                if (typeof account === "string")
+                    this.rejecting.add(account);
+            // Each conversation's last request time, so a restart does not make
+            // every open conversation "unseen" (cold) and rewrite a warm cache.
+            for (const [key, last, requests] of data.convs ?? []) {
+                if (typeof key === "string" && typeof last === "number")
+                    this.convs.set(key, { last: last + CONV_SAVE_MS, requests: Number(requests) || 1 });
+            }
         }
         catch {
             /* a corrupt state file only means results may be re-cleared once */
         }
     }
-    save() {
-        if (!this.dirty || !this.opts.statePath)
+    save(force = false) {
+        if (!this.opts.statePath)
+            return;
+        const due = this.convsDirty && (force || Date.now() - this.lastSave >= CONV_SAVE_MS);
+        if (!this.dirty && !due)
             return;
         this.dirty = false;
+        this.convsDirty = false;
+        this.lastSave = Date.now();
         try {
             // Newest 50k ids: far more than any live session holds.
             const entries = [...this.cleared.entries()].slice(-50_000);
+            const convs = [...this.convs.entries()].map(([k, c]) => [k, c.last, c.requests]);
             mkdirSync(dirname(this.opts.statePath), { recursive: true });
-            writeFileSync(this.opts.statePath, JSON.stringify({ cleared: entries }));
+            writeFileSync(this.opts.statePath, JSON.stringify({ cleared: entries, convs, rejectsEdits: [...this.rejecting] }));
         }
         catch {
             /* persistence is best effort */