opencode-anthropic-fix 0.1.19 → 0.1.21

package/index.mjs

@@ -19,6 +19,9 @@ import {
   parseShouldRetryHeader,
   TRANSIENT_RETRY_THRESHOLD_MS,
 } from "./lib/backoff.mjs";
+import { callHaiku } from "./lib/haiku-call.mjs";
+import { summarize as rollingSummarize } from "./lib/rolling-summarizer.mjs";
+import { staleReadEviction, perToolClassPrune } from "./lib/message-transform.mjs";
 
 // ---------------------------------------------------------------------------
 // Account management CLI prompts
@@ -110,6 +113,58 @@ async function promptManageAccounts(accountManager) {
   }
 }
 
+/**
+ * Pure driver for experimental.session.summarize. Extracted from the handler
+ * closure so it can be unit-tested without bootstrapping the full plugin.
+ * All external dependencies are injected.
+ *
+ * @param {object} deps
+ * @param {object|null} deps.config - Plugin config; handler no-ops if config.token_economy_strategies.haiku_rolling_summary is not true.
+ * @param {() => Promise<string>} deps.getAccessToken - Resolves to a Bearer OAuth token (or throws).
+ * @param {typeof globalThis.fetch} deps.fetchFn - HTTP transport.
+ * @param {typeof callHaiku} deps.callHaikuFn - Haiku API caller.
+ * @param {typeof rollingSummarize} deps.rollingSummarizeFn - Deterministic summarizer.
+ * @param {{warn: (msg: string) => void}} [deps.logger] - For fall-through warnings.
+ * @param {{sessionID: string, messages: unknown[], model: unknown}} input
+ * @param {{summary?: string, modelID?: string, providerID?: string, tokens?: {input: number, output: number}, cost?: number}} output
+ */
+async function runHaikuSessionSummarize(
+  { config, getAccessToken, fetchFn, callHaikuFn, rollingSummarizeFn, logger },
+  input,
+  output,
+) {
+  if (!config?.token_economy_strategies?.haiku_rolling_summary) return;
+
+  try {
+    let capturedTokens = { input: 0, output: 0 };
+    let capturedCost = 0;
+    const haikuCall = async (request) => {
+      const r = await callHaikuFn({
+        prompt: request.prompt,
+        fetch: fetchFn,
+        getAccessToken,
+      });
+      capturedTokens = r.tokens;
+      capturedCost = r.cost;
+      return r.text;
+    };
+
+    const summaryText = await rollingSummarizeFn(input.messages, { haikuCall });
+    if (typeof summaryText !== "string" || summaryText.length === 0) return;
+
+    output.summary = summaryText;
+    output.modelID = "claude-haiku-4-5-20251001";
+    output.providerID = "anthropic";
+    output.tokens = capturedTokens;
+    output.cost = capturedCost;
+  } catch (err) {
+    if (logger && typeof logger.warn === "function") {
+      const msg = err && typeof err === "object" && "message" in err ? err.message : String(err);
+      logger.warn(`[opencode-anthropic-fix] haiku rolling summary failed; falling back to default compaction: ${msg}`);
+    }
+  }
+}
+
 export async function AnthropicAuthPlugin({ client, project, directory, worktree, serverUrl, $ }) {
   const config = loadConfig();
   _pluginConfig = config; // expose to module-level functions (cache stats, response headers)
@@ -4004,6 +4059,24 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
         },
       ],
     },
+    /**
+     * Stateless message-list transforms. Previously fork-only patches
+     * (4c3f4fc19 stale-read eviction, 797ae24d8 per-tool-class prune)
+     * now live here and apply on the cloned request messages. Hook
+     * input is `{}` — no sessionID, so these are global policies.
+     */
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const strategies = config?.token_economy_strategies;
+      if (!strategies) return;
+      if (!output?.messages) return;
+
+      if (strategies.stale_read_eviction) {
+        staleReadEviction({ messages: output.messages });
+      }
+      if (strategies.per_tool_class_prune) {
+        perToolClassPrune({ messages: output.messages });
+      }
+    },
     "experimental.session.compacting": async (input, output) => {
       // Reset adaptive context state on session compaction (new conversation boundary).
       // This prevents sticky escalation from leaking across conversations.
@@ -4045,6 +4118,41 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       // lib/rolling-summarizer.mjs — call summarize(messages, {haikuCall}) here
       // behind config.token_economy.rolling_summarizer when messages are available.
     },
+    /**
+     * B3 L2 Option C: Plugin-generated compaction summary via Haiku.
+     * Gated on token_economy_strategies.haiku_rolling_summary. See
+     * runHaikuSessionSummarize at the top of this file for the full driver
+     * — the closure here only binds account/token/config state.
+     */
+    "experimental.session.summarize": async (input, output) => {
+      if (!config?.token_economy_strategies?.haiku_rolling_summary) return;
+      if (!accountManager) return;
+
+      const account = accountManager.getCurrentAccount();
+      if (!account) return;
+
+      const getAccessToken = async () => {
+        let tok = account.access;
+        if (!tok || !account.expires || account.expires < Date.now()) {
+          tok = await refreshAccountTokenSingleFlight(account);
+        }
+        if (!tok) throw new Error("no access token available for Haiku call");
+        return tok;
+      };
+
+      await runHaikuSessionSummarize(
+        {
+          config,
+          getAccessToken,
+          fetchFn: globalThis.fetch,
+          callHaikuFn: callHaiku,
+          rollingSummarizeFn: rollingSummarize,
+          logger: typeof console !== "undefined" ? console : undefined,
+        },
+        input,
+        output,
+      );
+    },
   };
 }
 
@@ -8843,6 +8951,8 @@ AnthropicAuthPlugin.__testing__ = {
   // exposed for session-dedupe regression tests (phase C3)
   applySessionToolResultDedupe,
   maybeApplySessionToolResultDedupe,
+  // exposed for experimental.session.summarize integration tests
+  runHaikuSessionSummarize,
   get cachedCCPrompt() {
     return cachedCCPrompt;
   },

package/lib/config.mjs

@@ -305,6 +305,23 @@ export const DEFAULT_CONFIG = {
      *  10-20% on long sessions. Pure over message history → cache-stable.
      *  Off by default (conservative mode territory). */
     tool_result_dedupe_session_wide: false,
+    /** Haiku rolling-summary compaction: when a matching opencode fork
+     *  exposes the `experimental.session.summarize` hook, the plugin calls
+     *  claude-haiku-4-5-20251001 at temperature 0 to produce the compaction
+     *  summary, bypassing the main model. Requires opencode fork support
+     *  — no-op without it. Off by default. */
+    haiku_rolling_summary: false,
+    /** Stale-read eviction: replace `read`/`view` tool outputs from
+     *  messages older than N turns with a placeholder. Runs on every
+     *  request via `experimental.chat.messages.transform`. Saves
+     *  ~1-2KB per old read × conversation depth. Off by default. */
+    stale_read_eviction: false,
+    /** Per-tool-class prune thresholds: apply different token budgets
+     *  to reproducible (read/grep/glob/ls) vs stateful (bash/edit/write)
+     *  tool outputs during request assembly. Reproducible outputs can
+     *  be re-run on demand, so they prune at a lower threshold. Off by
+     *  default — when ON, uses 10_000/40_000 token budgets. */
+    per_tool_class_prune: false,
   },
   /** Output cap: default max_tokens to save context window. */
   output_cap: {
@@ -781,6 +798,18 @@ function validateConfig(raw) {
         typeof tes.tool_result_dedupe_session_wide === "boolean"
           ? tes.tool_result_dedupe_session_wide
           : DEFAULT_CONFIG.token_economy_strategies.tool_result_dedupe_session_wide,
+      haiku_rolling_summary:
+        typeof tes.haiku_rolling_summary === "boolean"
+          ? tes.haiku_rolling_summary
+          : DEFAULT_CONFIG.token_economy_strategies.haiku_rolling_summary,
+      stale_read_eviction:
+        typeof tes.stale_read_eviction === "boolean"
+          ? tes.stale_read_eviction
+          : DEFAULT_CONFIG.token_economy_strategies.stale_read_eviction,
+      per_tool_class_prune:
+        typeof tes.per_tool_class_prune === "boolean"
+          ? tes.per_tool_class_prune
+          : DEFAULT_CONFIG.token_economy_strategies.per_tool_class_prune,
     };
   }
 

package/lib/config.test.mjs

@@ -379,3 +379,82 @@ describe("loadConfig", () => {
     expect(config.adaptive_context.enabled).toBe(false);
   });
 });
+
+describe("token_economy_strategies.haiku_rolling_summary", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+
+  it("defaults to false when config file omits the flag", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({}));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+
+  it("accepts true when explicitly set in config file", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { haiku_rolling_summary: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value (graceful, does not throw)", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { haiku_rolling_summary: "yes" } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.haiku_rolling_summary).toBe(false);
+  });
+});
+
+describe("token_economy_strategies.stale_read_eviction", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.stale_read_eviction).toBe(false);
+  });
+
+  it("accepts true when explicitly set", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { stale_read_eviction: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.stale_read_eviction).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { stale_read_eviction: 1 } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.stale_read_eviction).toBe(false);
+  });
+});
+
+describe("token_economy_strategies.per_tool_class_prune", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("defaults to false in DEFAULT_CONFIG", () => {
+    expect(DEFAULT_CONFIG.token_economy_strategies.per_tool_class_prune).toBe(false);
+  });
+
+  it("accepts true when explicitly set", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { per_tool_class_prune: true } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.per_tool_class_prune).toBe(true);
+  });
+
+  it("falls back to default on non-boolean value", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ token_economy_strategies: { per_tool_class_prune: "on" } }));
+    const cfg = loadConfig();
+    expect(cfg.token_economy_strategies.per_tool_class_prune).toBe(false);
+  });
+});

package/lib/haiku-call.mjs

@@ -0,0 +1,44 @@
+export const MODEL = "claude-haiku-4-5-20251001";
+export const TEMPERATURE = 0;
+export const MAX_TOKENS = 2048;
+export const ANTHROPIC_VERSION = "2023-06-01";
+export const API_URL = "https://api.anthropic.com/v1/messages";
+
+// Haiku 4.5 pricing as of 2026-04-18 (USD per million tokens).
+const PRICE_INPUT_PER_MTOK = 1.0;
+const PRICE_OUTPUT_PER_MTOK = 5.0;
+
+export async function callHaiku({ prompt, fetch, getAccessToken }) {
+  const token = await getAccessToken();
+
+  const res = await fetch(API_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`,
+      "anthropic-version": ANTHROPIC_VERSION,
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      temperature: TEMPERATURE,
+      max_tokens: MAX_TOKENS,
+      messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Haiku call failed: HTTP ${res.status} ${body}`);
+  }
+
+  const json = await res.json();
+  const textBlock = (json.content ?? []).find((b) => b.type === "text");
+  if (!textBlock || typeof textBlock.text !== "string" || textBlock.text.length === 0) {
+    throw new Error("Haiku response has no text content");
+  }
+  const input = json.usage?.input_tokens ?? 0;
+  const output = json.usage?.output_tokens ?? 0;
+  const cost = (input / 1e6) * PRICE_INPUT_PER_MTOK + (output / 1e6) * PRICE_OUTPUT_PER_MTOK;
+
+  return { text: textBlock.text, tokens: { input, output }, cost };
+}

package/lib/haiku-call.test.mjs

@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from "vitest";
+import { callHaiku } from "./haiku-call.mjs";
+
+describe("callHaiku", () => {
+  it("returns text + tokens + cost on 200 response", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        content: [{ type: "text", text: "summary body here" }],
+        usage: { input_tokens: 100, output_tokens: 30 },
+      }),
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    const result = await callHaiku({
+      prompt: "summarize this",
+      fetch: fetchMock,
+      getAccessToken,
+    });
+
+    expect(result.text).toBe("summary body here");
+    expect(result.tokens).toEqual({ input: 100, output: 30 });
+    // Haiku 4.5 pricing: $1/MTok input, $5/MTok output (2026-04-18)
+    // cost = 100/1e6 * 1 + 30/1e6 * 5 = 0.0001 + 0.00015 = 0.00025
+    expect(result.cost).toBeCloseTo(0.00025, 8);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, opts] = fetchMock.mock.calls[0];
+    expect(url).toBe("https://api.anthropic.com/v1/messages");
+    expect(opts.method).toBe("POST");
+    expect(opts.headers.authorization).toBe("Bearer oauth-token-abc");
+    expect(opts.headers["anthropic-version"]).toBe("2023-06-01");
+    const body = JSON.parse(opts.body);
+    expect(body.model).toBe("claude-haiku-4-5-20251001");
+    expect(body.temperature).toBe(0);
+    expect(body.max_tokens).toBe(2048);
+    expect(body.messages).toEqual([{ role: "user", content: [{ type: "text", text: "summarize this" }] }]);
+  });
+
+  it("throws on non-2xx HTTP response", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: false,
+      status: 429,
+      text: async () => "rate limited",
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/HTTP 429/);
+  });
+
+  it("throws when response content is missing or not text", async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ content: [], usage: { input_tokens: 0, output_tokens: 0 } }),
+    }));
+    const getAccessToken = vi.fn(async () => "oauth-token-abc");
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/no text content/i);
+  });
+
+  it("throws when getAccessToken rejects", async () => {
+    const fetchMock = vi.fn();
+    const getAccessToken = vi.fn(async () => {
+      throw new Error("oauth expired");
+    });
+
+    await expect(callHaiku({ prompt: "x", fetch: fetchMock, getAccessToken })).rejects.toThrow(/oauth expired/);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/lib/message-transform.mjs

@@ -0,0 +1,132 @@
+/**
+ * Stateless message-list transforms applied via
+ * `experimental.chat.messages.transform` hook. The hook input is empty
+ * (`{}` — no sessionID, no agent role), so these policies are global to
+ * all sessions when enabled.
+ *
+ * The `messages` array passed to the hook is a `structuredClone` of the
+ * session state, so mutation is safe and ONLY affects the outbound
+ * request — storage is untouched.
+ */
+
+/** Tool names treated as read-class (content can be re-fetched). */
+export const STALE_READ_TOOLS = new Set(["read", "view"]);
+
+/** Tool names trivially re-runnable (idempotent + cheap). */
+export const REPRODUCIBLE_TOOLS = new Set(["read", "grep", "glob", "ls", "list", "find"]);
+
+/** Tools never pruned (provider-critical, e.g. skill catalog). */
+const PRUNE_PROTECTED_TOOLS = new Set(["skill"]);
+
+/** Replacement text for stale read outputs. */
+const STALE_READ_PLACEHOLDER = "[File was read earlier in this session — re-read if you need the current contents]";
+
+/** Rough char-to-token ratio — same heuristic opencode uses for estimates. */
+function estimateTokens(text) {
+  if (typeof text !== "string" || text.length === 0) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Replace read/view tool outputs from messages older than `threshold`
+ * messages-from-end with a placeholder note, and drop their attachments.
+ *
+ * Stateless. Does NOT mutate storage. Only affects the outbound request.
+ *
+ * @param {{messages: Array<{info: any, parts: any[]}>, threshold?: number, tools?: Set<string>}} args
+ * @returns {{evicted: number}} — how many tool parts were rewritten
+ */
+export function staleReadEviction({ messages, threshold = 10, tools = STALE_READ_TOOLS }) {
+  if (!Array.isArray(messages) || messages.length <= threshold) {
+    return { evicted: 0 };
+  }
+
+  const cutoff = messages.length - threshold;
+  let evicted = 0;
+
+  for (let i = 0; i < cutoff; i++) {
+    const msg = messages[i];
+    if (!msg?.parts) continue;
+
+    for (const part of msg.parts) {
+      if (part?.type !== "tool") continue;
+      if (part.state?.status !== "completed") continue;
+      if (part.state.time?.compacted) continue;
+      if (!tools.has(part.tool)) continue;
+
+      part.state.output = STALE_READ_PLACEHOLDER;
+      if (part.state.attachments) {
+        part.state.attachments = [];
+      }
+      evicted++;
+    }
+  }
+
+  return { evicted };
+}
+
+/**
+ * Prune older tool outputs by class, keeping the most recent N tokens
+ * worth per class (reproducible vs stateful). Walks backward from the
+ * end; once a class's running total exceeds its threshold, older outputs
+ * of that class are replaced with empty strings.
+ *
+ * Stateless. Mirrors the core `compaction.prune()` logic but applies at
+ * request-assembly time instead of persisting to storage.
+ *
+ * @param {{messages: Array<{info: any, parts: any[]}>, reproducibleThreshold?: number, statefulThreshold?: number, reproducibleTools?: Set<string>}} args
+ * @returns {{pruned: number, tokensSaved: number}}
+ */
+export function perToolClassPrune({
+  messages,
+  reproducibleThreshold = 10_000,
+  statefulThreshold = 40_000,
+  reproducibleTools = REPRODUCIBLE_TOOLS,
+}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return { pruned: 0, tokensSaved: 0 };
+  }
+
+  let totalReproducible = 0;
+  let totalStateful = 0;
+  let pruned = 0;
+  let tokensSaved = 0;
+
+  // Walk backward through messages; within each message, also backward
+  // through parts — matches the original prune() ordering.
+  outer: for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!msg?.parts?.length) continue;
+
+    for (let j = msg.parts.length - 1; j >= 0; j--) {
+      const part = msg.parts[j];
+      if (part?.type !== "tool") continue;
+      if (part.state?.status !== "completed") continue;
+      if (PRUNE_PROTECTED_TOOLS.has(part.tool)) continue;
+      if (part.state.time?.compacted) break outer;
+
+      const estimate = estimateTokens(part.state.output);
+      const isReproducible = reproducibleTools.has(part.tool.toLowerCase());
+
+      if (isReproducible) {
+        totalReproducible += estimate;
+        if (totalReproducible > reproducibleThreshold) {
+          part.state.output = "";
+          if (part.state.attachments) part.state.attachments = [];
+          pruned++;
+          tokensSaved += estimate;
+        }
+      } else {
+        totalStateful += estimate;
+        if (totalStateful > statefulThreshold) {
+          part.state.output = "";
+          if (part.state.attachments) part.state.attachments = [];
+          pruned++;
+          tokensSaved += estimate;
+        }
+      }
+    }
+  }
+
+  return { pruned, tokensSaved };
+}

package/lib/message-transform.test.mjs

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+import { staleReadEviction, perToolClassPrune, STALE_READ_TOOLS, REPRODUCIBLE_TOOLS } from "./message-transform.mjs";
+
+/** Build a message with a single tool part. */
+function toolMsg(tool, output, { compacted = false, attachments } = {}) {
+  return {
+    info: { role: "assistant", id: `msg-${Math.random()}` },
+    parts: [
+      {
+        type: "tool",
+        callID: "c1",
+        tool,
+        state: {
+          status: "completed",
+          input: {},
+          output,
+          title: "t",
+          metadata: {},
+          time: { start: 0, end: 1, ...(compacted ? { compacted: 1 } : {}) },
+          ...(attachments ? { attachments } : {}),
+        },
+      },
+    ],
+  };
+}
+
+describe("staleReadEviction", () => {
+  it("is a no-op when messages <= threshold", () => {
+    const msgs = [toolMsg("read", "content")];
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe("content");
+  });
+
+  it("replaces read output older than threshold with placeholder", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("read", `file ${i} content`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(5);
+    expect(msgs[0].parts[0].state.output).toMatch(/re-read if you need/);
+    expect(msgs[4].parts[0].state.output).toMatch(/re-read if you need/);
+    expect(msgs[5].parts[0].state.output).toBe("file 5 content");
+    expect(msgs[14].parts[0].state.output).toBe("file 14 content");
+  });
+
+  it("leaves non-read tools untouched", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("bash", `cmd ${i} output`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe("cmd 0 output");
+  });
+
+  it("skips already-compacted tool parts", () => {
+    const msgs = [
+      toolMsg("read", "stale but compacted", { compacted: true }),
+      ...Array.from({ length: 11 }, (_, i) => toolMsg("read", `x${i}`)),
+    ];
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(1);
+    expect(msgs[0].parts[0].state.output).toBe("stale but compacted");
+    expect(msgs[1].parts[0].state.output).toMatch(/re-read if you need/);
+  });
+
+  it("strips attachments when evicting", () => {
+    const msgs = Array.from({ length: 15 }, (_, i) =>
+      toolMsg("read", `file ${i}`, {
+        attachments: [{ type: "file", mime: "image/png", url: "x" }],
+      }),
+    );
+    staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(msgs[0].parts[0].state.attachments).toEqual([]);
+    expect(msgs[14].parts[0].state.attachments).toHaveLength(1);
+  });
+
+  it("accepts `view` as a read-class tool", () => {
+    expect(STALE_READ_TOOLS.has("view")).toBe(true);
+    const msgs = Array.from({ length: 15 }, (_, i) => toolMsg("view", `content ${i}`));
+    const { evicted } = staleReadEviction({ messages: msgs, threshold: 10 });
+    expect(evicted).toBe(5);
+  });
+
+  it("handles empty/missing messages gracefully", () => {
+    expect(staleReadEviction({ messages: [] }).evicted).toBe(0);
+    expect(staleReadEviction({ messages: null }).evicted).toBe(0);
+  });
+});
+
+describe("perToolClassPrune", () => {
+  it("prunes old reproducible outputs over the 10k threshold", () => {
+    const output = "x".repeat(30_000); // ~7_500 tokens (chars/4)
+    const msgs = Array.from({ length: 3 }, () => toolMsg("read", output));
+    const { pruned, tokensSaved } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+    });
+    // Walk backward: newest (7_500) fits under 10k, older 2 push total over → pruned.
+    expect(pruned).toBe(2);
+    expect(tokensSaved).toBeGreaterThan(10_000);
+    expect(msgs[2].parts[0].state.output).toBe(output); // newest kept
+    expect(msgs[0].parts[0].state.output).toBe("");
+    expect(msgs[1].parts[0].state.output).toBe("");
+  });
+
+  it("uses higher threshold for stateful tools (bash)", () => {
+    const mid = "x".repeat(50_000); // ~12_500 tokens
+    const msgs = Array.from({ length: 3 }, () => toolMsg("bash", mid));
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      statefulThreshold: 40_000,
+    });
+    // 3 × 12_500 = 37_500 < 40_000 → nothing pruned
+    expect(pruned).toBe(0);
+  });
+
+  it("never prunes protected tools (skill)", () => {
+    const big = "x".repeat(500_000); // ~125_000 tokens — would bust any threshold
+    const msgs = Array.from({ length: 3 }, () => toolMsg("skill", big));
+    const { pruned } = perToolClassPrune({ messages: msgs });
+    expect(pruned).toBe(0);
+    expect(msgs[0].parts[0].state.output).toBe(big);
+  });
+
+  it("stops walking back when it hits a compacted part", () => {
+    const big = "x".repeat(50_000);
+    const msgs = [
+      toolMsg("read", "must-not-prune-old", { compacted: true }),
+      ...Array.from({ length: 3 }, () => toolMsg("read", big)),
+    ];
+    perToolClassPrune({ messages: msgs, reproducibleThreshold: 10_000 });
+    // Compacted sentinel preserved; walk terminates before reaching it.
+    expect(msgs[0].parts[0].state.output).toBe("must-not-prune-old");
+  });
+
+  it("tracks reproducible and stateful budgets independently", () => {
+    const output = "x".repeat(30_000); // ~7_500 tokens each
+    // interleave: read, bash, read, bash, read, bash (oldest to newest)
+    const msgs = [
+      toolMsg("read", output),
+      toolMsg("bash", output),
+      toolMsg("read", output),
+      toolMsg("bash", output),
+      toolMsg("read", output),
+      toolMsg("bash", output),
+    ];
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+      statefulThreshold: 40_000,
+    });
+    // reads: 7_500, 15_000 → over → prune; 22_500 → prune. 2 old reads pruned.
+    // bash:  7_500, 15_000, 22_500 → all under 40k → 0 pruned.
+    expect(pruned).toBe(2);
+    expect(msgs[4].parts[0].state.output).toBe(output); // newest read kept
+    expect(msgs[5].parts[0].state.output).toBe(output); // newest bash kept
+    expect(msgs[0].parts[0].state.output).toBe(""); // oldest read pruned
+    expect(msgs[2].parts[0].state.output).toBe(""); // middle read pruned
+  });
+
+  it("normalizes tool name case when classifying", () => {
+    expect(REPRODUCIBLE_TOOLS.has("read")).toBe(true);
+    const output = "x".repeat(30_000); // ~7_500 tokens
+    const msgs = Array.from({ length: 3 }, () => toolMsg("READ", output));
+    const { pruned } = perToolClassPrune({
+      messages: msgs,
+      reproducibleThreshold: 10_000,
+    });
+    expect(pruned).toBe(2);
+  });
+
+  it("handles empty/missing messages gracefully", () => {
+    expect(perToolClassPrune({ messages: [] }).pruned).toBe(0);
+    expect(perToolClassPrune({ messages: null }).pruned).toBe(0);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [