context-doctor 0.13.0 → 0.13.1

package/dist/config.d.ts

@@ -39,11 +39,19 @@ export interface LoadedConfig {
     config: ContextDoctorConfig;
     /** Absolute path of the rc file, or undefined when none was found. */
     path?: string;
+    /** Settings that will be silently ignored, if any. */
+    warnings?: string[];
 }
 /**
- * Load the nearest config. Malformed rc files are reported (so a typo is not
- * silently ignored) but never throw — the tool keeps working with defaults.
+ * Report anything in an rc file that will be silently ignored.
+ *
+ * Every invalid value here fails quietly and looks like the feature not
+ * working: `"trim-tool-result"` (missing s) trims nothing, a negative
+ * keepRecent disables trimming entirely, and a budget written as a string is
+ * never compared against. For a tool whose whole job is measurement, silently
+ * doing nothing is the worst available behaviour.
  */
+export declare function validateConfig(config: unknown, path: string): string[];
 export declare function loadConfig(startDir?: string, onWarn?: (msg: string) => void): LoadedConfig;
 export interface BudgetVerdict {
     /** True when any configured limit is exceeded. */

package/dist/config.js

@@ -36,14 +36,88 @@ function candidatePaths(startDir) {
  * Load the nearest config. Malformed rc files are reported (so a typo is not
  * silently ignored) but never throw — the tool keeps working with defaults.
  */
+/** Strategy ids the optimizer actually implements. */
+const KNOWN_STRATEGIES = new Set(["dedupe", "trim-tool-results", "trim-tool-calls", "strip-base64", "prune-history"]);
+const KNOWN_KEYS = new Set(["budget", "strategies", "keepRecent", "maxToolResultTokens", "routes", "model"]);
+const KNOWN_BUDGET_KEYS = new Set(["maxTokens", "maxCostPerMessageUsd", "maxWindowPct"]);
+/**
+ * Report anything in an rc file that will be silently ignored.
+ *
+ * Every invalid value here fails quietly and looks like the feature not
+ * working: `"trim-tool-result"` (missing s) trims nothing, a negative
+ * keepRecent disables trimming entirely, and a budget written as a string is
+ * never compared against. For a tool whose whole job is measurement, silently
+ * doing nothing is the worst available behaviour.
+ */
+export function validateConfig(config, path) {
+    const warnings = [];
+    const where = (key) => `${path}: ${key}`;
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        return [`${path}: expected a JSON object`];
+    }
+    const c = config;
+    for (const key of Object.keys(c)) {
+        if (!KNOWN_KEYS.has(key)) {
+            warnings.push(`${where(key)} is not a known setting — ignored (known: ${[...KNOWN_KEYS].join(", ")})`);
+        }
+    }
+    if (c.budget !== undefined) {
+        if (typeof c.budget !== "object" || c.budget === null || Array.isArray(c.budget)) {
+            warnings.push(`${where("budget")} must be an object — ignored`);
+        }
+        else {
+            const budget = c.budget;
+            for (const [key, value] of Object.entries(budget)) {
+                if (!KNOWN_BUDGET_KEYS.has(key)) {
+                    warnings.push(`${where(`budget.${key}`)} is not a known budget limit — ignored`);
+                }
+                else if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+                    warnings.push(`${where(`budget.${key}`)} must be a positive number, got ${JSON.stringify(value)} — this limit will never trigger`);
+                }
+            }
+            if (typeof budget.maxWindowPct === "number" && budget.maxWindowPct > 100) {
+                warnings.push(`${where("budget.maxWindowPct")} is above 100 — a percentage of the context window cannot exceed 100`);
+            }
+        }
+    }
+    if (c.strategies !== undefined) {
+        if (!Array.isArray(c.strategies)) {
+            warnings.push(`${where("strategies")} must be an array — ignored`);
+        }
+        else {
+            for (const id of c.strategies) {
+                if (!KNOWN_STRATEGIES.has(String(id))) {
+                    warnings.push(`${where("strategies")}: "${id}" is not a strategy — ignored (known: ${[...KNOWN_STRATEGIES].join(", ")})`);
+                }
+            }
+        }
+    }
+    for (const key of ["keepRecent", "maxToolResultTokens"]) {
+        const value = c[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+            warnings.push(`${where(key)} must be a positive whole number, got ${JSON.stringify(value)} — ignored`);
+        }
+    }
+    if (c.routes !== undefined && !Array.isArray(c.routes)) {
+        warnings.push(`${where("routes")} must be an array — ignored`);
+    }
+    return warnings;
+}
 export function loadConfig(startDir = process.cwd(), onWarn) {
     for (const path of candidatePaths(startDir)) {
         if (!existsSync(path))
             continue;
         try {
             const parsed = JSON.parse(readFileSync(path, "utf8"));
-            if (parsed && typeof parsed === "object")
-                return { config: parsed, path };
+            // Arrays are objects too, hence the explicit check.
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                const warnings = validateConfig(parsed, path);
+                for (const warning of warnings)
+                    onWarn?.(warning);
+                return { config: parsed, path, warnings };
+            }
             onWarn?.(`${path}: expected a JSON object — ignoring`);
         }
         catch (e) {

package/dist/dashboard.js

@@ -7,7 +7,7 @@
  * the server reads local files and answers only the loopback interface.
  */
 import http from "node:http";
-import { readLedger } from "./ledger.js";
+import { foldTotals, readLedger } from "./ledger.js";
 import { listSessions, parseSessionFile } from "./session.js";
 import { parseConversation } from "./parse.js";
 import { profileConversation } from "./profile.js";
@@ -28,6 +28,9 @@ async function fetchProxyStats(port) {
 }
 export async function collectDashboardData(proxyPort = 8787) {
     const ledger = readLedger();
+    // Totals folded in when the ledger rotated; excluded from the daily series,
+    // which describes individual days rather than a carried-forward sum.
+    const carried = foldTotals(ledger.filter((e) => e.ev === "rollup"));
     const checks = ledger.filter((e) => e.ev === "check" || e.ev === undefined);
     const optimizes = ledger.filter((e) => e.ev === "optimize");
     // Observed shrinkage: a session getting SMALLER between two deep checks is a
@@ -38,14 +41,14 @@ export async function collectDashboardData(proxyPort = 8787) {
             continue;
         perSession.set(c.sid, [...(perSession.get(c.sid) ?? []), c.tok]);
     }
-    let shrinkage = 0;
+    let shrinkage = carried.shrinkage;
     for (const toks of perSession.values()) {
         for (let i = 1; i < toks.length; i++)
             if (toks[i] < toks[i - 1])
                 shrinkage += toks[i - 1] - toks[i];
     }
-    const optimizeSaved = optimizes.reduce((s, e) => s + (e.saved ?? 0), 0);
-    let usdSaved = 0;
+    const optimizeSaved = optimizes.reduce((s, e) => s + (e.saved ?? 0), 0) + carried.optimizeSaved;
+    let usdSaved = carried.optimizeUsd;
     for (const e of optimizes) {
         const pricing = pricingFor(e.model);
         if (pricing && e.saved)
@@ -93,8 +96,8 @@ export async function collectDashboardData(proxyPort = 8787) {
         totals: {
             tokensSaved: optimizeSaved + shrinkage + (proxy?.tokensSaved ?? 0),
             usdSaved: usdSaved + (proxy?.estUsdSaved ?? 0),
-            checks: checks.length,
-            warnings: checks.filter((c) => c.warn).length,
+            checks: checks.length + carried.checks,
+            warnings: checks.filter((c) => c.warn).length + carried.warnings,
             optimizeRuns: optimizes.length,
         },
         daily,

package/dist/doctor.js

@@ -11,6 +11,7 @@ import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ledgerPath, recordLedger } from "./ledger.js";
+import { loadConfig } from "./config.js";
 function claudeDesktopConfigPath() {
     switch (platform()) {
         case "darwin": return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
@@ -120,6 +121,18 @@ export async function runDoctor() {
     catch {
         checks.push({ label: "Ledger", status: "fail", detail: `cannot write ${ledgerPath()}` });
     }
+    // Project config: a setting that is silently ignored looks exactly like the
+    // feature being broken, so name it here rather than leaving it to be guessed.
+    const loaded = loadConfig(process.cwd());
+    if (loaded.path) {
+        const warnings = loaded.warnings ?? [];
+        checks.push(warnings.length === 0
+            ? { label: "Project config", status: "ok", detail: `${loaded.path} — all settings understood` }
+            : { label: "Project config", status: "fail", detail: `${warnings.length} setting(s) will be ignored:\n` + warnings.map((w) => `    ${w}`).join("\n") });
+    }
+    else {
+        checks.push({ label: "Project config", status: "skip", detail: "no .contextdoctorrc (optional; create one with: context-doctor init <preset>)" });
+    }
     checks.push(await checkMcpHandshake());
     const mark = { ok: "✓", fail: "✗", skip: "–" };
     console.log("CONTEXT DOCTOR — self-check");

package/dist/hook.js

@@ -10,7 +10,9 @@
  * Registered by `context-doctor install` under hooks.UserPromptSubmit in
  * ~/.claude/settings.json; removed by `context-doctor uninstall`.
  */
-import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
 import { recordLedger, statePath } from "./ledger.js";
 import { parseConversation } from "./parse.js";
 import { profileConversation } from "./profile.js";
@@ -43,6 +45,70 @@ const REGROWTH_FACTOR = 1.4;
 function minBytesForWarn(threshold) {
     return threshold * 4;
 }
+/**
+ * State lives in one small file per session, not one shared map.
+ *
+ * The hook runs once per prompt in every Claude Code window, and people keep
+ * several open. With a shared JSON map, concurrent hooks each read the whole
+ * map and wrote it back, so the last writer erased everyone else: measured,
+ * 12 simultaneous sessions left 4 surviving entries. The cost of losing an
+ * entry is a repeated warning the regrowth gate exists to prevent, plus a full
+ * re-parse of a transcript that can be hundreds of megabytes.
+ *
+ * A process that only ever writes its own session's file cannot race another.
+ */
+function stateDir() {
+    return statePath().replace(/\.json$/, "") + ".d";
+}
+function sessionStatePath(sessionId) {
+    // Session ids are usually uuids, but the fallback id is a filesystem path.
+    // Hashing keeps the filename valid whatever the id looks like.
+    return join(stateDir(), createHash("sha1").update(sessionId).digest("hex").slice(0, 16) + ".json");
+}
+function readSessionState(sessionId) {
+    try {
+        const raw = JSON.parse(readFileSync(sessionStatePath(sessionId), "utf8"));
+        if (typeof raw?.t === "number" && typeof raw?.b === "number")
+            return raw;
+    }
+    catch {
+        /* absent or half-written: treat as a first run */
+    }
+    // Migration: entries written by the shared-map versions are still useful.
+    try {
+        const legacy = JSON.parse(readFileSync(statePath(), "utf8"));
+        const entry = legacy[sessionId];
+        if (typeof entry === "number")
+            return { t: entry, b: 0 };
+        if (entry && typeof entry.t === "number")
+            return { t: entry.t, b: entry.b ?? 0 };
+    }
+    catch {
+        /* no legacy file */
+    }
+    return { t: 0, b: 0 };
+}
+/** Keep the directory from growing without bound as sessions come and go. */
+const MAX_STATE_FILES = 200;
+function writeSessionState(sessionId, state) {
+    const dir = stateDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(sessionStatePath(sessionId), JSON.stringify(state));
+    try {
+        const files = readdirSync(dir);
+        if (files.length <= MAX_STATE_FILES)
+            return;
+        const byAge = files
+            .map((f) => ({ f, t: statSync(join(dir, f)).mtimeMs }))
+            .sort((a, b) => b.t - a.t)
+            .slice(MAX_STATE_FILES);
+        for (const { f } of byAge)
+            rmSync(join(dir, f), { force: true });
+    }
+    catch {
+        /* pruning is housekeeping, never worth failing a prompt over */
+    }
+}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -68,16 +134,7 @@ export async function runHook() {
         // since the last full parse, nothing new can trigger — exit without the
         // expensive read. Heavy-but-quiet sessions cost one stat + tiny state read.
         const sessionId = input.session_id ?? transcriptPath;
-        let state = {};
-        try {
-            state = JSON.parse(readFileSync(statePath(), "utf8"));
-        }
-        catch {
-            /* first run */
-        }
-        const rawPrev = state[sessionId];
-        // Migrate pre-0.3.5 numeric entries ({tokens only}) to the new shape.
-        const prev = typeof rawPrev === "number" ? { t: rawPrev, b: 0 } : rawPrev ?? { t: 0, b: 0 };
+        const prev = readSessionState(sessionId);
         if (prev.b > 0 && sizeBytes < prev.b * REGROWTH_FACTOR)
             return;
         // Slow path (growth events only): full parse + profile.
@@ -91,9 +148,7 @@ export async function runHook() {
         const liveTokens = parsed.reportedInputTokens ?? profile.totalTokens;
         // Record this parse so the next prompts take fast path 2.
         const shouldWarn = liveTokens >= threshold && liveTokens >= prev.t * REGROWTH_FACTOR;
-        const nextState = { t: shouldWarn ? liveTokens : prev.t, b: sizeBytes };
-        const entries = Object.entries({ ...state, [sessionId]: nextState });
-        writeFileSync(statePath(), JSON.stringify(Object.fromEntries(entries.slice(-100))));
+        writeSessionState(sessionId, { t: shouldWarn ? liveTokens : prev.t, b: sizeBytes });
         recordLedger({ ev: "check", sid: sessionId.slice(0, 12), tok: liveTokens, warn: shouldWarn });
         if (!shouldWarn)
             return;

package/dist/impact.js

@@ -8,7 +8,7 @@
  * session cannot be re-run without it. The report says so instead of inventing
  * a number.
  */
-import { readLedger } from "./ledger.js";
+import { foldTotals, readLedger } from "./ledger.js";
 import { listSessions, parseSessionFile } from "./session.js";
 import { parseConversation } from "./parse.js";
 import { profileConversation } from "./profile.js";
@@ -32,6 +32,9 @@ export async function buildImpactReport(proxyPort = 8787) {
     lines.push("CONTEXT DOCTOR — impact report");
     lines.push("═".repeat(56));
     const ledger = readLedger();
+    // Rotation folds dropped entries into a rollup. Counting it is what keeps
+    // these lifetime totals from going backwards once the cap is hit.
+    const carried = foldTotals(ledger.filter((e) => e.ev === "rollup"));
     const checks = ledger.filter((e) => e.ev === "check" || e.ev === undefined);
     const optimizes = ledger.filter((e) => e.ev === "optimize");
     // Observed per-session reductions: when a session SHRANK between two deep
@@ -55,9 +58,9 @@ export async function buildImpactReport(proxyPort = 8787) {
         }
         reductionBySession.set(sid, reduction);
     }
-    const totalReduction = [...reductionBySession.values()].reduce((a, b) => a + b, 0);
+    const totalReduction = [...reductionBySession.values()].reduce((a, b) => a + b, 0) + carried.shrinkage;
     // Optimize-event savings, split by model family (claude / gpt / other).
-    const optimizeSaved = optimizes.reduce((s, e) => s + (e.saved ?? 0), 0);
+    const optimizeSaved = optimizes.reduce((s, e) => s + (e.saved ?? 0), 0) + carried.optimizeSaved;
     const savedByFamily = new Map();
     let optimizeUsd = 0;
     for (const e of optimizes) {
@@ -71,7 +74,7 @@ export async function buildImpactReport(proxyPort = 8787) {
     // Persisted checkpoints cover proxy runs that have since exited; the live
     // process reports whatever it has not checkpointed yet.
     const proxyEvents = ledger.filter((e) => e.ev === "proxy");
-    const proxyHistoric = proxyEvents.reduce((s, e) => s + (e.saved ?? 0), 0);
+    const proxyHistoric = proxyEvents.reduce((s, e) => s + (e.saved ?? 0), 0) + carried.proxySaved;
     const proxySaved = proxyHistoric + (proxy?.tokensSaved ?? 0);
     // -- Headline: what context-doctor has saved ----------------------------------
     const totalSaved = proxySaved + optimizeSaved + totalReduction;
@@ -100,8 +103,8 @@ export async function buildImpactReport(proxyPort = 8787) {
     lines.push("Hygiene activity (every-prompt hook)");
     lines.push("─".repeat(56));
     if (checks.length > 0) {
-        const warnings = checks.filter((e) => e.warn).length;
-        lines.push(`${checks.length} deep context checks across ${bySession.size} session(s); ${warnings} warning(s) delivered to the model.`);
+        const warnings = checks.filter((e) => e.warn).length + carried.warnings;
+        lines.push(`${checks.length + carried.checks} deep context checks across ${bySession.size} session(s); ${warnings} warning(s) delivered to the model.`);
         lines.push("(Prompt-level fast checks are not logged — they cost ~1ms and leave no trace by design.)");
     }
     else {

package/dist/ledger.d.ts

@@ -8,10 +8,16 @@
  *              (pre-0.3.6 hook entries have no `ev` field; treated as checks)
  *   optimize — an optimization was applied  {ev: "optimize", src: "cli"|"mcp", saved, model?}
  *   proxy    — proxy savings checkpoint      {ev: "proxy", saved, usd?, requests?}
+ *   rollup   — totals folded in on rotation   {ev: "rollup", ...carried sums}
+ *
+ * The ledger is capped, and everything it feeds is a LIFETIME total. Simply
+ * dropping old lines made those totals go backwards — measured: 1,692,000
+ * tokens saved became 501,000 the moment the cap was hit. So rotation folds
+ * what it drops into a single rollup entry instead of discarding it.
  */
 export interface LedgerEntry {
     ts: number;
-    ev?: "check" | "optimize" | "proxy";
+    ev?: "check" | "optimize" | "proxy" | "rollup";
     sid?: string;
     tok?: number;
     warn?: boolean;
@@ -20,7 +26,30 @@ export interface LedgerEntry {
     requests?: number;
     saved?: number;
     model?: string;
+    /** rollup only: sums carried forward from entries rotation removed. */
+    carried?: CarriedTotals;
+}
+/** Everything the reports total up, preserved across ledger rotation. */
+export interface CarriedTotals {
+    optimizeSaved: number;
+    optimizeUsd: number;
+    proxySaved: number;
+    proxyUsd: number;
+    proxyRequests: number;
+    checks: number;
+    warnings: number;
+    /** Session shrinkage observed between consecutive checks. */
+    shrinkage: number;
+    /** Timestamp of the oldest folded entry, so reports can say "since". */
+    since?: number;
 }
+/**
+ * Reduce a set of entries to the totals the reports care about.
+ *
+ * Absorbs existing rollups, so folding stays correct across any number of
+ * rotations rather than only the first.
+ */
+export declare function foldTotals(entries: LedgerEntry[]): CarriedTotals;
 export declare function statePath(): string;
 export declare function ledgerPath(): string;
 export declare function recordLedger(entry: Omit<LedgerEntry, "ts">): void;

package/dist/ledger.js

@@ -8,10 +8,68 @@
  *              (pre-0.3.6 hook entries have no `ev` field; treated as checks)
  *   optimize — an optimization was applied  {ev: "optimize", src: "cli"|"mcp", saved, model?}
  *   proxy    — proxy savings checkpoint      {ev: "proxy", saved, usd?, requests?}
+ *   rollup   — totals folded in on rotation   {ev: "rollup", ...carried sums}
+ *
+ * The ledger is capped, and everything it feeds is a LIFETIME total. Simply
+ * dropping old lines made those totals go backwards — measured: 1,692,000
+ * tokens saved became 501,000 the moment the cap was hit. So rotation folds
+ * what it drops into a single rollup entry instead of discarding it.
  */
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+const EMPTY_CARRIED = {
+    optimizeSaved: 0, optimizeUsd: 0, proxySaved: 0, proxyUsd: 0,
+    proxyRequests: 0, checks: 0, warnings: 0, shrinkage: 0,
+};
+/**
+ * Reduce a set of entries to the totals the reports care about.
+ *
+ * Absorbs existing rollups, so folding stays correct across any number of
+ * rotations rather than only the first.
+ */
+export function foldTotals(entries) {
+    const out = { ...EMPTY_CARRIED };
+    const perSession = new Map();
+    for (const e of entries) {
+        if (e.ev === "rollup" && e.carried) {
+            out.optimizeSaved += e.carried.optimizeSaved;
+            out.optimizeUsd += e.carried.optimizeUsd;
+            out.proxySaved += e.carried.proxySaved;
+            out.proxyUsd += e.carried.proxyUsd;
+            out.proxyRequests += e.carried.proxyRequests;
+            out.checks += e.carried.checks;
+            out.warnings += e.carried.warnings;
+            out.shrinkage += e.carried.shrinkage;
+            if (e.carried.since)
+                out.since = Math.min(out.since ?? e.carried.since, e.carried.since);
+            continue;
+        }
+        out.since = Math.min(out.since ?? e.ts, e.ts);
+        if (e.ev === "optimize") {
+            out.optimizeSaved += e.saved ?? 0;
+            out.optimizeUsd += e.usd ?? 0;
+        }
+        else if (e.ev === "proxy") {
+            out.proxySaved += e.saved ?? 0;
+            out.proxyUsd += e.usd ?? 0;
+            out.proxyRequests += e.requests ?? 0;
+        }
+        else {
+            out.checks++;
+            if (e.warn)
+                out.warnings++;
+            if (e.sid && typeof e.tok === "number")
+                perSession.set(e.sid, [...(perSession.get(e.sid) ?? []), e.tok]);
+        }
+    }
+    for (const toks of perSession.values()) {
+        for (let i = 1; i < toks.length; i++)
+            if (toks[i] < toks[i - 1])
+                out.shrinkage += toks[i - 1] - toks[i];
+    }
+    return out;
+}
 export function statePath() {
     return process.env.CONTEXT_DOCTOR_HOOK_STATE ?? join(homedir(), ".claude", ".context-doctor-hook-state.json");
 }
@@ -24,10 +82,24 @@ export function recordLedger(entry) {
         // Claude-Desktop-only machines have no ~/.claude — create it so their
         // optimize events count in `context-doctor report` too.
         mkdirSync(dirname(path), { recursive: true });
-        // Cap growth: past ~256KB keep the most recent 500 entries.
+        // Cap growth: past ~256KB keep the most recent 500 entries — but fold the
+        // dropped ones into a rollup first, or every lifetime total in the reports
+        // silently shrinks the moment a heavy user crosses the cap.
         if (existsSync(path) && statSync(path).size > 256 * 1024) {
             const lines = readFileSync(path, "utf8").trimEnd().split("\n");
-            writeFileSync(path, lines.slice(-500).join("\n") + "\n");
+            const parse = (line) => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            };
+            const kept = lines.slice(-500);
+            const dropped = lines.slice(0, -500).flatMap(parse);
+            const carried = foldTotals(dropped);
+            const rollup = { ts: Date.now(), ev: "rollup", carried };
+            writeFileSync(path, [JSON.stringify(rollup), ...kept].join("\n") + "\n");
         }
         appendFileSync(path, JSON.stringify({ ts: Date.now(), ...entry }) + "\n");
     }

package/dist/mcp.js

@@ -37,7 +37,7 @@ const STRATEGY_IDS = ["dedupe", "trim-tool-results", "trim-tool-calls", "strip-b
  * recommended pattern.
  */
 function createServer() {
-    const server = new McpServer({ name: "context-doctor", version: "0.13.0" }, { instructions: SERVER_INSTRUCTIONS });
+    const server = new McpServer({ name: "context-doctor", version: "0.13.1" }, { instructions: SERVER_INSTRUCTIONS });
     server.tool("profile_context", "Profile an LLM conversation or prompt: token breakdown by category, largest messages, and actionable findings about wasted context (duplicates, oversized tool results, base64 blobs, cache-unfriendly ordering). Accepts OpenAI/Anthropic conversation JSON or raw text. Call this immediately whenever the user asks about token usage, context size, LLM cost, or latency — and proactively offer it once a conversation grows long or accumulates large pasted content.", {
         conversation: z.string().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array) or raw prompt text"),
         model: z.string().optional().describe("Target model name for context-window math, e.g. claude-sonnet-5 or gpt-4o"),

package/dist/optimize.js

@@ -182,11 +182,24 @@ export function optimizeConversation(input, options = {}) {
     }
     // -- dedupe: identical content beyond the first occurrence --------------------
     if (opts.strategies.includes("dedupe")) {
+        // The recent tail is what the model is actually answering. Replacing a
+        // message there with "identical to #0" is technically true and practically
+        // awful: through the proxy, a user who pastes the same document twice has
+        // their CURRENT question swapped for a pointer to a message ten turns back,
+        // and just sees a worse answer with no explanation. Older copies are fair
+        // game; the live turn is not.
+        const cutoff = stableCutoff(messages.length, opts.keepRecent);
         const seen = new Map();
         messages.forEach((m, i) => {
             const text = textOf(m.content);
             if (text.length < 300)
                 return;
+            if (i >= cutoff) {
+                // Still record it, so a later duplicate can point back here.
+                if (!seen.has(hash(text)))
+                    seen.set(hash(text), i);
+                return;
+            }
             const h = hash(text);
             const first = seen.get(h);
             if (first === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-doctor",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Profile and optimize LLM context windows. See what's eating your tokens and fix it — works with Claude, GPT, Gemini, and any MCP-capable AI app.",
   "keywords": [
     "llm",
@@ -42,7 +42,7 @@
     "build": "tsc && node -e \"const fs=require('fs');['dist/cli.js','dist/mcp.js'].forEach(f=>fs.chmodSync(f,0o755))\"",
     "prepublishOnly": "npm run build",
     "dev": "tsc --watch",
-    "test": "npm run build && node --test dist/test/smoke.test.js dist/test/proxy.test.js dist/test/proxy-abort.test.js dist/test/hook.test.js dist/test/mcp-http.test.js dist/test/doctor.test.js dist/test/watch.test.js dist/test/chatgpt-export.test.js dist/test/config.test.js dist/test/dashboard.test.js dist/test/cursor.test.js dist/test/cache.test.js dist/test/session.test.js dist/test/accuracy.test.js dist/test/cache-stability.test.js"
+    "test": "npm run build && node --test dist/test/smoke.test.js dist/test/proxy.test.js dist/test/proxy-abort.test.js dist/test/hook.test.js dist/test/mcp-http.test.js dist/test/doctor.test.js dist/test/watch.test.js dist/test/chatgpt-export.test.js dist/test/config.test.js dist/test/dashboard.test.js dist/test/cursor.test.js dist/test/cache.test.js dist/test/session.test.js dist/test/accuracy.test.js dist/test/cache-stability.test.js dist/test/ledger.test.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",