context-doctor 0.13.0 → 0.13.2

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/cursor.js

@@ -114,7 +114,12 @@ export function listCursorChats(limit = 20) {
             rows = queryRows(dbPath, "SELECT key, json_extract(value, '$.name') AS name, " +
                 "COALESCE(json_array_length(value, '$.fullConversationHeadersOnly'), " +
                 "json_array_length(value, '$.conversation'), 0) AS n " +
-                "FROM cursorDiskKV WHERE key LIKE 'composerData:%'");
+                // json_valid is not optional: SQLite's JSON functions raise on
+                // malformed input, and one non-JSON row under a composerData: key
+                // aborts the WHOLE query. cursorDiskKV is a general-purpose store,
+                // so that row exists sooner or later — and the user then sees
+                // "No Cursor chats found" with every real chat sitting right there.
+                "FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND json_valid(value)");
         }
         catch {
             continue; // no composer table (older Cursor) or no SQLite — skip

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.2" }, { 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"),
@@ -120,6 +120,24 @@ const BEST_PRACTICES = {
         "Use max_completion_tokens headroom math: input + output must fit the window together.",
     ],
 };
+/**
+ * Set a header on a Node request so every downstream reader sees it.
+ *
+ * `req.headers` is a parsed convenience copy; the MCP transport reconstructs a
+ * Web Request from `req.rawHeaders`, so a header written to only one of them is
+ * invisible to the other.
+ */
+function setHeader(req, name, value) {
+    req.headers[name] = value;
+    const raw = req.rawHeaders;
+    for (let i = 0; i < raw.length; i += 2) {
+        if (raw[i].toLowerCase() === name) {
+            raw[i + 1] = value;
+            return;
+        }
+    }
+    raw.push(name, value);
+}
 // -- Transport dispatch --------------------------------------------------------
 // Default: stdio (Claude Desktop, Claude Code, Cursor spawn us as a child).
 // --http [--port N] [--host H]: streamable-HTTP endpoint at /mcp for clients
@@ -154,9 +172,26 @@ if (argv.includes("--http")) {
                 res.end(JSON.stringify({ error: "Stateless server: POST /mcp only" }));
                 return;
             }
+            // The streamable-HTTP spec says a client MUST accept both
+            // application/json and text/event-stream, and the SDK answers anything
+            // else with a 406. Plenty of real callers send only application/json, or
+            // `*/*`, or no Accept at all — and to them a 406 looks like the server
+            // being broken. Our replies are single JSON-RPC responses with nothing to
+            // stream, so those clients get a plain JSON body instead of a refusal.
+            const accept = String(req.headers.accept ?? "");
+            const askedForSse = accept.includes("text/event-stream");
+            if (!askedForSse || !accept.includes("application/json")) {
+                // The transport rebuilds the request from rawHeaders (via Hono), so
+                // setting req.headers alone changes nothing it will ever look at.
+                setHeader(req, "accept", "application/json, text/event-stream");
+            }
             // Fresh server + transport per request (stateless — nothing shared).
             const server = createServer();
-            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                // A client that never asked for a stream gets plain JSON back.
+                enableJsonResponse: !askedForSse,
+            });
             res.on("close", () => {
                 void transport.close();
                 void server.close();

package/dist/optimize.js

@@ -129,6 +129,34 @@ function truncateToTokens(text, maxTokens) {
     const omitted = text.length - approxChars;
     return `${head}\n…[context-doctor: trimmed ${omitted} chars of stale tool output]`;
 }
+/**
+ * Remove tool_result blocks whose matching tool_use is not in the same slice.
+ *
+ * Anthropic and OpenAI both reject a conversation where a tool result refers to
+ * a call that is not present, so anything that drops earlier turns has to clean
+ * up after itself. A message emptied by this keeps a short note rather than
+ * becoming an empty content array, which is also rejected.
+ */
+function dropOrphanedToolResults(kept) {
+    const availableCalls = new Set();
+    for (const m of kept) {
+        if (!Array.isArray(m?.content))
+            continue;
+        for (const b of m.content)
+            if (b?.type === "tool_use" && b.id)
+                availableCalls.add(b.id);
+    }
+    for (const m of kept) {
+        if (!Array.isArray(m?.content))
+            continue;
+        const surviving = m.content.filter((b) => b?.type !== "tool_result" || (b.tool_use_id && availableCalls.has(b.tool_use_id)));
+        if (surviving.length === m.content.length)
+            continue;
+        m.content = surviving.length > 0
+            ? surviving
+            : [{ type: "text", text: "[context-doctor: earlier tool result dropped with the pruned history]" }];
+    }
+}
 function isToolResultMessage(m) {
     if (m?.role === "tool")
         return true;
@@ -182,11 +210,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) {
@@ -209,6 +250,11 @@ export function optimizeConversation(input, options = {}) {
             if (before <= opts.maxToolResultTokens)
                 return;
             const trimmed = truncateToTokens(text, opts.maxToolResultTokens);
+            // The truncation notice has a length of its own, so a result only just
+            // over the budget can come back LARGER than it went in. Measured on a
+            // real session: 2,941 tokens "optimized" to 2,947.
+            if (estimateTokens(trimmed) >= before)
+                return;
             m.content = replaceText(m.content, trimmed);
             applied.push({
                 strategy: "trim-tool-results",
@@ -233,8 +279,13 @@ export function optimizeConversation(input, options = {}) {
                     const before = estimateTokens(JSON.stringify(b.input));
                     if (before <= opts.maxToolResultTokens)
                         continue;
-                    b.input = trimCallArguments(b.input, opts.maxToolResultTokens);
-                    saved += before - estimateTokens(JSON.stringify(b.input));
+                    const trimmedInput = trimCallArguments(b.input, opts.maxToolResultTokens);
+                    // Same trap as tool results: the marker can outweigh what it replaces.
+                    const after = estimateTokens(JSON.stringify(trimmedInput));
+                    if (after >= before)
+                        continue;
+                    b.input = trimmedInput;
+                    saved += before - after;
                 }
             }
             // OpenAI shape: tool_calls[].function.arguments is a JSON string.
@@ -272,6 +323,11 @@ export function optimizeConversation(input, options = {}) {
         // Boundary adjustment may leave too little tail to be worth keeping —
         // in that case skip pruning entirely rather than gutting the conversation.
         if (messages.length - keepFrom >= 2) {
+            // Advancing past LEADING tool results is not enough: a tool_result can
+            // sit deeper in the kept tail while its tool_use was pruned, and both
+            // APIs reject a conversation containing an orphan. Measured on a real
+            // 1,011-message session, which pruned to 7 messages with one orphan.
+            dropOrphanedToolResults(messages.slice(keepFrom));
             const pruned = messages.slice(0, keepFrom);
             const prunedTokens = pruned.reduce((s, m) => s + estimateTokens(textOf(m.content)), 0);
             // Digest: first ~200 chars of each pruned turn — enough for a host LLM to

package/dist/pricing.js

@@ -42,6 +42,9 @@ export function estimatedTtftSeconds(inputTokens) {
     return inputTokens / 25_000;
 }
 export function formatUsd(amount) {
+    // Same reasoning as formatTokens: "$NaN" is worse than "$0.00".
+    if (!Number.isFinite(amount))
+        return "$0.00";
     if (amount >= 1)
         return `$${amount.toFixed(2)}`;
     if (amount >= 0.01)

package/dist/session.js

@@ -12,6 +12,17 @@ import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, cl
 import { StringDecoder } from "node:string_decoder";
 import { homedir } from "node:os";
 import { join } from "node:path";
+/**
+ * Read one usage field defensively.
+ *
+ * A numeric string plainly means that number, and discarding it would throw
+ * away ground truth and silently fall back to the heuristic — so it is parsed.
+ * Anything else unusable (objects, null, "abc", negatives) counts as nothing.
+ */
+function usageNumber(value) {
+    const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+    return Number.isFinite(n) && n >= 0 ? Math.round(n) : 0;
+}
 function projectsDir() {
     return join(homedir(), ".claude", "projects");
 }
@@ -45,6 +56,21 @@ export function listSessions(limit = 20) {
  * conversations.json is an array of conversations, each holding a `mapping`
  * tree of nodes. We profile the most recently updated conversation.
  */
+/**
+ * A stand-in for a non-text export part.
+ *
+ * The bytes are not in the export, so the exact token cost is unknowable; what
+ * matters is that the turn stops being invisible and keeps its place in the
+ * conversation.
+ */
+function chatGptAttachmentLabel(part) {
+    const kind = part?.content_type;
+    if (typeof kind === "string")
+        return `[${kind}]`;
+    if (part?.asset_pointer)
+        return "[image]";
+    return "[attachment]";
+}
 function parseChatGPTExport(data, path) {
     const conversations = data
         .filter((c) => c && typeof c.mapping === "object")
@@ -58,12 +84,21 @@ function parseChatGPTExport(data, path) {
         if (!m?.author?.role || !["user", "assistant", "system"].includes(m.author.role))
             return false;
         const parts = m.content?.parts;
-        return Array.isArray(parts) && parts.some((p) => typeof p === "string" && p.length > 0);
+        if (!Array.isArray(parts))
+            return false;
+        // A turn containing an image is exported as multimodal_text, with the
+        // picture as an object among the string parts. Requiring a non-empty
+        // string dropped those turns entirely, so an image-heavy conversation
+        // profiled as smaller than it is.
+        return parts.some((p) => (typeof p === "string" && p.length > 0) || (p && typeof p === "object"));
     })
         .sort((a, b) => (a.message.create_time ?? 0) - (b.message.create_time ?? 0));
     const messages = nodes.map((n) => ({
         role: n.message.author.role,
-        content: n.message.content.parts.filter((p) => typeof p === "string").join("\n"),
+        content: n.message.content.parts
+            .map((p) => (typeof p === "string" ? p : chatGptAttachmentLabel(p)))
+            .filter((p) => p.length > 0)
+            .join("\n"),
     }));
     return {
         conversationJson: JSON.stringify({ messages }),
@@ -170,7 +205,13 @@ export function parseSessionFile(path) {
             model = message.model;
         const usage = message.usage;
         if (entry.type === "assistant" && usage) {
-            const total = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+            // Coerce, do not trust: a transcript whose usage numbers are STRINGS
+            // turned `1200 + 300` into "12003000" through JavaScript concatenation,
+            // an 8000x overstatement that drives the hook, the cost figures and the
+            // window percentage. Anything not a finite non-negative number is 0.
+            const total = usageNumber(usage.input_tokens) +
+                usageNumber(usage.cache_read_input_tokens) +
+                usageNumber(usage.cache_creation_input_tokens);
             if (total > 0) {
                 reportedInputTokens = total;
                 usageSamples.push({ index: messages.length, input: total });

package/dist/tokens.js

@@ -50,6 +50,10 @@ function symbolDensity(text) {
     return (symbols?.length ?? 0) / text.length;
 }
 export function estimateTokens(text) {
+    // Public API: callers outside this package pass whatever they have, and a
+    // TypeError from a token estimator is never the useful answer.
+    if (typeof text !== "string")
+        text = String(text ?? "");
     if (!text)
         return 0;
     // Denser tokenization for code/JSON-like content, lighter for plain prose.
@@ -60,6 +64,10 @@ export function estimateTokens(text) {
 /** Per-message structural overhead (role markers, delimiters) is roughly constant. */
 export const MESSAGE_OVERHEAD_TOKENS = 4;
 export function formatTokens(n) {
+    // A NaN reaching a report renders literally as "NaN tokens"; show nothing
+    // rather than something false.
+    if (!Number.isFinite(n))
+        return "0";
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
     if (n >= 10_000)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-doctor",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "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",