context-doctor 0.8.0 → 0.9.0

package/README.md

@@ -310,9 +310,16 @@ A tool that promises speed must be near-free. Measured overhead per touchpoint:
 
 Net effect is strongly negative overhead: the tokens these touchpoints save on every subsequent call dwarf what they cost.
 
-## Why token counts are "~" (and how to make them exact)
+## Why token counts are "~" (and where they are exact)
 
-Want exact numbers? `analyze --exact` uses the **Anthropic count-tokens API** for Claude models (set `ANTHROPIC_API_KEY`; opt-in network call, key never stored) or **tiktoken** for GPT models (install it next to context-doctor) — and reports how far off the heuristic was.
+Counting exactly needs each provider's tokenizer, so the default is a calibrated chars-per-token heuristic (denser for code and JSON). It is good enough to rank what is heavy and to measure the effect of a fix, and it keeps the tool offline and zero-config.
+
+Two ways to get real numbers instead:
+
+- **`analyze --exact`** uses the Anthropic count-tokens API for Claude models (set `ANTHROPIC_API_KEY`; opt-in network call, key never stored) or tiktoken for GPT models (install it alongside), and reports how far the heuristic drifted.
+- **Sessions report measured tokens automatically.** Claude Code transcripts record what the API actually charged, so `session`, the hook and the reports use that figure when it is present — no key, no estimate.
+
+One honest caveat worth knowing: a transcript stores the conversation, **not** the harness's system prompt, tool schemas or skills. Measured against the API's own numbers here, a message-only estimate undercounts the true context by roughly 60%. That is why sessions prefer the reported figure, and why the message breakdown is labelled as covering messages only.
 
 
 

package/dist/cli.js

@@ -25,6 +25,7 @@ import { runWatch } from "./watch.js";
 import { exactTokenCount } from "./exact.js";
 import { checkBudget, loadConfig } from "./config.js";
 import { startDashboard } from "./dashboard.js";
+import { listCursorChats, parseCursorChat } from "./cursor.js";
 const HELP = `context-doctor — profile and optimize LLM context windows
 
 Usage:
@@ -35,8 +36,9 @@ Usage:
   context-doctor install                        Wire the MCP server + skill into Claude Desktop,
                                                 Claude Code, and Cursor automatically
   context-doctor uninstall                      Undo install
-  context-doctor session [file]                 Profile a Claude Code session transcript
-                                                (default: the most recent session; --list to browse)
+  context-doctor session [file]                 Profile a Claude Code session transcript or a
+                                                ChatGPT export (default: most recent; --list to browse)
+  context-doctor cursor [--list]                Profile a Cursor chat from its local history
   context-doctor hook                           Claude Code UserPromptSubmit hook (installed
                                                 automatically by \`install\`; reads hook JSON on stdin)
   context-doctor report                         Impact report: exact proxy savings, hook activity,
@@ -185,6 +187,45 @@ function main() {
         void buildImpactReport(args.port).then((r) => console.log(r));
         return;
     }
+    if (args.command === "cursor") {
+        let chats;
+        try {
+            chats = listCursorChats();
+        }
+        catch (e) {
+            console.error(`Could not read Cursor history: ${e.message}`);
+            process.exit(1);
+        }
+        if (chats.length === 0) {
+            console.error("No Cursor chats found (looked in Cursor's global and workspace storage).");
+            process.exit(1);
+        }
+        if (args.list) {
+            for (const c of chats) {
+                console.log(`${String(c.messageCount).padStart(5)} msgs  ${(c.title ?? "(untitled)").slice(0, 48).padEnd(50)} ${c.composerId}`);
+            }
+            return;
+        }
+        const chat = args.file ? chats.find((c) => c.composerId === args.file) ?? chats[0] : chats[0];
+        const parsed = parseCursorChat(chat);
+        const profile = profileConversation(parseConversation(parsed.conversationJson), args.model ?? parsed.model);
+        if (args.json) {
+            console.log(JSON.stringify({ chat: { id: chat.composerId, title: chat.title }, profile }, null, 2));
+        }
+        else {
+            console.log(`Cursor chat: ${chat.title ?? "(untitled)"}\nId:          ${chat.composerId}\n`);
+            console.log(renderProfile(profile));
+            if (parsed.reportedInputTokens) {
+                console.log("");
+                console.log(`Measured context (reported by the API on the last request): ${parsed.reportedInputTokens} tokens.\n` +
+                    "That figure includes the harness's system prompt, tool schemas and skills, which the\n" +
+                    "transcript does not record — so it is larger than the breakdown above, which covers\n" +
+                    "conversation messages only. Findings and savings apply to the messages.");
+            }
+            printBudgetStatus(profile, loadConfig(process.cwd(), (m) => console.error(`context-doctor: ${m}`)));
+        }
+        return;
+    }
     if (args.command === "session") {
         if (args.list) {
             const sessions = listSessions();
@@ -215,8 +256,19 @@ function main() {
             console.log(JSON.stringify({ session: { path: parsed.path, title: parsed.title }, profile }, null, 2));
         }
         else {
-            console.log(`Session: ${parsed.title ?? "(untitled)"}\nFile:    ${parsed.path}\n`);
+            console.log(`Session: ${parsed.title ?? "(untitled)"}\nFile:    ${parsed.path}`);
+            if (parsed.compactedAway) {
+                console.log(`Note:    ${parsed.compactedAway} earlier message(s) were compacted away and are NOT counted below — this is the live context the model still sees.`);
+            }
+            console.log("");
             console.log(renderProfile(profile));
+            if (parsed.reportedInputTokens) {
+                console.log("");
+                console.log(`Measured context (reported by the API on the last request): ${parsed.reportedInputTokens} tokens.\n` +
+                    "That figure includes the harness's system prompt, tool schemas and skills, which the\n" +
+                    "transcript does not record — so it is larger than the breakdown above, which covers\n" +
+                    "conversation messages only. Findings and savings apply to the messages.");
+            }
             printBudgetStatus(profile, loadConfig(process.cwd(), (m) => console.error(`context-doctor: ${m}`)));
         }
         return;

package/dist/cursor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Cursor chat history: profile the conversations Cursor stores locally.
+ *
+ * Cursor keeps chats in SQLite (`state.vscdb`) rather than files:
+ *   composerData:<composerId>  → { name, conversation: [{bubbleId, type}] }
+ *   bubbleId:<composerId>:<id> → { type: 1|2, text, toolFormerData, ... }
+ * Message text lives in the per-bubble rows, so a conversation is assembled by
+ * walking the header list and looking up each bubble.
+ *
+ * Reading needs SQLite. Node 22.5+ ships `node:sqlite`; older runtimes fall
+ * back to the `sqlite3` CLI when it is installed. When neither is available we
+ * say so plainly instead of failing obscurely.
+ */
+import type { ParsedSession } from "./session.js";
+export interface CursorChat {
+    composerId: string;
+    title?: string;
+    dbPath: string;
+    messageCount: number;
+}
+/** Every Cursor state database on this machine, newest first. */
+export declare function findCursorDatabases(): string[];
+interface Row {
+    [column: string]: string | number | null;
+}
+/**
+ * Run a read-only query against a Cursor database.
+ *
+ * Two hard rules learned the expensive way:
+ *  - NEVER copy the file. A real Cursor history is gigabytes; snapshotting it
+ *    per invocation fills the disk.
+ *  - Project in SQL, not in JS. Composer rows hold megabytes of JSON each, so
+ *    listing pulls only the fields it needs via json_extract.
+ * SQLite allows concurrent readers, so opening the live database read-only is
+ * safe while Cursor is running.
+ */
+export declare function queryRows(dbPath: string, sql: string): Row[];
+/** List Cursor chats, biggest first. */
+export declare function listCursorChats(limit?: number): CursorChat[];
+/**
+ * Assemble one Cursor chat into a conversation this tool can profile.
+ * Tool calls are folded in as tool_use/tool_result blocks so the profiler's
+ * tool-result findings apply to Cursor chats exactly as they do elsewhere.
+ */
+export declare function parseCursorChat(chat: CursorChat): ParsedSession;
+export {};

package/dist/cursor.js

@@ -0,0 +1,203 @@
+/**
+ * Cursor chat history: profile the conversations Cursor stores locally.
+ *
+ * Cursor keeps chats in SQLite (`state.vscdb`) rather than files:
+ *   composerData:<composerId>  → { name, conversation: [{bubbleId, type}] }
+ *   bubbleId:<composerId>:<id> → { type: 1|2, text, toolFormerData, ... }
+ * Message text lives in the per-bubble rows, so a conversation is assembled by
+ * walking the header list and looking up each bubble.
+ *
+ * Reading needs SQLite. Node 22.5+ ships `node:sqlite`; older runtimes fall
+ * back to the `sqlite3` CLI when it is installed. When neither is available we
+ * say so plainly instead of failing obscurely.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+const require = createRequire(import.meta.url);
+/** Cursor bubble type codes. */
+const BUBBLE_USER = 1;
+/** Header list for a composer record, whichever shape it uses. */
+function headersOf(data) {
+    if (Array.isArray(data.conversation) && data.conversation.length > 0)
+        return data.conversation;
+    return data.fullConversationHeadersOnly ?? [];
+}
+/** Cursor's per-user storage root, per platform. */
+function cursorStorageDirs() {
+    const home = homedir();
+    const root = platform() === "darwin"
+        ? join(home, "Library", "Application Support", "Cursor", "User")
+        : platform() === "win32"
+            ? join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "Cursor", "User")
+            : join(home, ".config", "Cursor", "User");
+    const dirs = [];
+    const global = join(root, "globalStorage");
+    if (existsSync(global))
+        dirs.push(global);
+    const ws = join(root, "workspaceStorage");
+    if (existsSync(ws)) {
+        try {
+            for (const entry of readdirSync(ws))
+                dirs.push(join(ws, entry));
+        }
+        catch {
+            /* unreadable — skip */
+        }
+    }
+    return dirs;
+}
+/** Every Cursor state database on this machine, newest first. */
+export function findCursorDatabases() {
+    const dbs = [];
+    for (const dir of cursorStorageDirs()) {
+        const db = join(dir, "state.vscdb");
+        if (!existsSync(db))
+            continue;
+        try {
+            dbs.push({ path: db, mtime: statSync(db).mtimeMs });
+        }
+        catch {
+            /* unreadable — skip */
+        }
+    }
+    return dbs.sort((a, b) => b.mtime - a.mtime).map((d) => d.path);
+}
+/**
+ * Run a read-only query against a Cursor database.
+ *
+ * Two hard rules learned the expensive way:
+ *  - NEVER copy the file. A real Cursor history is gigabytes; snapshotting it
+ *    per invocation fills the disk.
+ *  - Project in SQL, not in JS. Composer rows hold megabytes of JSON each, so
+ *    listing pulls only the fields it needs via json_extract.
+ * SQLite allows concurrent readers, so opening the live database read-only is
+ * safe while Cursor is running.
+ */
+export function queryRows(dbPath, sql) {
+    try {
+        // Preferred: Node's built-in SQLite (22.5+).
+        const { DatabaseSync } = require("node:sqlite");
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        try {
+            return db.prepare(sql).all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (nodeSqliteErr) {
+        // Fallback: the sqlite3 CLI, if the user has it.
+        try {
+            const out = execFileSync("sqlite3", ["-readonly", "-json", dbPath, sql], {
+                encoding: "utf8",
+                maxBuffer: 512 * 1024 * 1024,
+                stdio: ["ignore", "pipe", "ignore"], // a missing table is expected on some DBs
+            });
+            return out.trim() ? JSON.parse(out) : [];
+        }
+        catch {
+            throw new Error("reading Cursor chats needs SQLite: Node 22.5+ (built-in) or the sqlite3 command. " +
+                `Neither worked here (${nodeSqliteErr.message}).`);
+        }
+    }
+}
+/** List Cursor chats, biggest first. */
+export function listCursorChats(limit = 20) {
+    const chats = [];
+    for (const dbPath of findCursorDatabases()) {
+        let rows;
+        try {
+            // json_extract keeps megabyte-sized composer blobs in the database.
+            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:%'");
+        }
+        catch {
+            continue; // no composer table (older Cursor) or no SQLite — skip
+        }
+        for (const row of rows) {
+            const count = Number(row.n ?? 0);
+            if (count === 0)
+                continue;
+            chats.push({
+                composerId: String(row.key).slice("composerData:".length),
+                title: row.name == null ? undefined : String(row.name),
+                dbPath,
+                messageCount: count,
+            });
+        }
+    }
+    return chats.sort((a, b) => b.messageCount - a.messageCount).slice(0, limit);
+}
+function safeParse(raw) {
+    if (typeof raw !== "string")
+        return raw ?? {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function stringify(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+/**
+ * Assemble one Cursor chat into a conversation this tool can profile.
+ * Tool calls are folded in as tool_use/tool_result blocks so the profiler's
+ * tool-result findings apply to Cursor chats exactly as they do elsewhere.
+ */
+export function parseCursorChat(chat) {
+    const id = chat.composerId.replace(/[^a-zA-Z0-9-]/g, "");
+    const header = queryRows(chat.dbPath, `SELECT value FROM cursorDiskKV WHERE key = 'composerData:${id}'`)[0];
+    const record = header ? JSON.parse(String(header.value)) : {};
+    const conversation = headersOf(record);
+    const bubbleRows = queryRows(chat.dbPath, `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:${id}:%'`);
+    const byId = new Map();
+    for (const row of bubbleRows) {
+        try {
+            byId.set(String(row.key).split(":").pop() ?? "", JSON.parse(String(row.value)));
+        }
+        catch {
+            /* malformed bubble — skip */
+        }
+    }
+    const messages = [];
+    for (const entry of conversation) {
+        // Legacy entries carry their own text; modern ones point at a bubble row.
+        const bubble = (entry.bubbleId ? byId.get(entry.bubbleId) : undefined) ?? entry;
+        const role = (bubble.type ?? entry.type) === BUBBLE_USER ? "user" : "assistant";
+        const text = typeof bubble.text === "string" ? bubble.text : "";
+        const tool = bubble.toolFormerData;
+        if (tool && (tool.name || tool.rawArgs || tool.result)) {
+            if (text)
+                messages.push({ role, content: text });
+            messages.push({
+                role: "assistant",
+                content: [{ type: "tool_use", id: entry.bubbleId ?? "tool", name: String(tool.name ?? "tool"), input: safeParse(tool.rawArgs) }],
+            });
+            if (tool.result !== undefined) {
+                messages.push({
+                    role: "user",
+                    content: [{ type: "tool_result", tool_use_id: entry.bubbleId ?? "tool", content: stringify(tool.result) }],
+                });
+            }
+            continue;
+        }
+        if (!text)
+            continue;
+        messages.push({ role, content: text });
+    }
+    return {
+        conversationJson: JSON.stringify({ messages }),
+        title: chat.title,
+        // Cursor does not record the model per chat in a stable place; leaving it
+        // unset keeps window/cost math honest rather than guessed.
+        messageCount: messages.length,
+        path: `${chat.dbPath}#${chat.composerId}`,
+    };
+}

package/dist/hook.js

@@ -85,23 +85,31 @@ export async function runHook() {
         if (parsed.messageCount === 0)
             return;
         const profile = profileConversation(parseConversation(parsed.conversationJson), parsed.model);
+        // Prefer the API's own figure when the transcript carries it: it includes
+        // the system prompt and tool schemas the transcript omits, so it is the
+        // real context size rather than a message-only estimate.
+        const liveTokens = parsed.reportedInputTokens ?? profile.totalTokens;
         // Record this parse so the next prompts take fast path 2.
-        const shouldWarn = profile.totalTokens >= threshold && profile.totalTokens >= prev.t * REGROWTH_FACTOR;
-        const nextState = { t: shouldWarn ? profile.totalTokens : prev.t, b: sizeBytes };
+        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))));
-        recordLedger({ ev: "check", sid: sessionId.slice(0, 12), tok: profile.totalTokens, warn: shouldWarn });
+        recordLedger({ ev: "check", sid: sessionId.slice(0, 12), tok: liveTokens, warn: shouldWarn });
         if (!shouldWarn)
             return;
+        const windowPct = profile.contextWindow ? (liveTokens / profile.contextWindow) * 100 : undefined;
+        const costPerCall = profile.cost && profile.totalTokens > 0
+            ? (profile.cost.perCallUsd * liveTokens) / profile.totalTokens
+            : undefined;
         const lines = [
-            `This session's context is at ~${formatTokens(profile.totalTokens)} tokens` +
-                (profile.usagePct ? ` (${profile.usagePct.toFixed(0)}% of the window)` : "") +
-                (profile.cost ? `, costing ~${formatUsd(profile.cost.perCallUsd)} of input per message` : "") +
+            `This session's context is at ~${formatTokens(liveTokens)} tokens` +
+                (windowPct !== undefined ? ` (${windowPct.toFixed(0)}% of the window)` : "") +
+                (costPerCall !== undefined ? `, costing ~${formatUsd(costPerCall)} of input per message` : "") +
                 ".",
             "Practice context hygiene from here on: summarize large tool results instead of keeping them verbatim, reference earlier content rather than re-reading or re-quoting it, and keep responses lean.",
         ];
         // A configured budget is the user's own limit — say so first and by name.
-        const verdict = checkBudget(config.budget, profile);
+        const verdict = checkBudget(config.budget, { ...profile, totalTokens: liveTokens, usagePct: windowPct });
         if (verdict.overBudget) {
             lines.splice(1, 0, `This project's context budget is exceeded: ${verdict.breaches.join("; ")}. Treat compaction as a priority, not an option.`);
         }
@@ -109,7 +117,7 @@ export async function runHook() {
         if (topFinding) {
             lines.push(`Largest recoverable waste: ${topFinding.message} (${topFinding.suggestion})`);
         }
-        if (profile.totalTokens > threshold * 2) {
+        if (liveTokens > threshold * 2) {
             lines.push("If it fits the flow, offer the user a compaction of the older history.");
         }
         console.log(JSON.stringify({

package/dist/impact.js

@@ -102,7 +102,7 @@ export async function buildImpactReport(proxyPort = 8787) {
     }
     lines.push("");
     // -- Measured-now: recent session profiles ------------------------------------
-    lines.push("Your recent sessions — waste still recoverable today");
+    lines.push("Your recent sessions — live context and waste still recoverable");
     lines.push("─".repeat(56));
     const sessions = listSessions(8).filter((s) => s.sizeBytes <= MAX_SESSION_BYTES);
     if (sessions.length === 0) {

package/dist/mcp.js

@@ -37,7 +37,7 @@ const STRATEGY_IDS = ["dedupe", "trim-tool-results", "strip-base64", "prune-hist
  * recommended pattern.
  */
 function createServer() {
-    const server = new McpServer({ name: "context-doctor", version: "0.8.0" }, { instructions: SERVER_INSTRUCTIONS });
+    const server = new McpServer({ name: "context-doctor", version: "0.9.0" }, { 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/profile.js

@@ -15,6 +15,40 @@ function categoryOf(m) {
         default: return "other";
     }
 }
+/**
+ * Total recoverable tokens, counted as a UNION rather than a sum.
+ *
+ * Findings legitimately overlap: an oversized tool result can also be a
+ * near-duplicate, and a long history contains both. Adding their estimates
+ * would promise savings the same tokens can only deliver once. Each
+ * message-scoped finding is attributed to the message that would actually be
+ * removed (the LAST index — for a duplicate pair, the later copy), keeping the
+ * largest claim per message; whole-conversation findings then take only what
+ * is left unclaimed. The result is capped below the total, since no
+ * optimization reclaims an entire context.
+ */
+function unionSavings(findings, totalTokens) {
+    const perMessage = new Map();
+    let unscoped = 0;
+    for (const f of findings) {
+        if (f.estSavings <= 0)
+            continue;
+        if (f.messages.length === 0) {
+            unscoped += f.estSavings;
+            continue;
+        }
+        const target = f.messages[f.messages.length - 1];
+        perMessage.set(target, Math.max(perMessage.get(target) ?? 0, f.estSavings));
+    }
+    const scoped = [...perMessage.values()].reduce((a, b) => a + b, 0);
+    // Whole-conversation findings can only claim tokens no message-scoped
+    // finding already claimed.
+    const headroom = Math.max(0, totalTokens - scoped);
+    const total = scoped + Math.min(unscoped, headroom);
+    // A context can never be optimized away entirely; 90% is the ceiling any
+    // strategy set could plausibly reach.
+    return Math.min(total, Math.round(totalTokens * 0.9));
+}
 function preview(text, len = 90) {
     const clean = text.replace(/\s+/g, " ").trim();
     return clean.length > len ? clean.slice(0, len) + "…" : clean;
@@ -235,7 +269,7 @@ export function profileConversation(conv, model) {
         .slice(0, 5);
     const severityRank = { high: 0, warn: 1, info: 2 };
     findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.estSavings - a.estSavings);
-    const totalEstSavings = findings.reduce((s, f) => s + f.estSavings, 0);
+    const totalEstSavings = unionSavings(findings, totalTokens);
     const pricing = pricingFor(model);
     let cost;
     if (pricing) {

package/dist/session.d.ts

@@ -15,6 +15,21 @@ export interface SessionInfo {
     sizeBytes: number;
 }
 export interface ParsedSession {
+    /**
+     * The real input size of the most recent request, as reported by the API
+     * (input + cache-read + cache-creation tokens). Transcripts do not contain
+     * the harness's system prompt, tool schemas or skills, so an estimate over
+     * transcript messages alone undercounts badly — measured against these
+     * figures, by roughly 60%. When this is present, prefer it: it is ground
+     * truth rather than an estimate.
+     */
+    reportedInputTokens?: number;
+    /**
+     * Messages dropped because a compaction replaced them. Reporting live
+     * context means counting only what the model still sees; this records what
+     * was compacted away so the difference can be shown rather than hidden.
+     */
+    compactedAway?: number;
     /** Conversation JSON string in Anthropic-ish format, ready for parseConversation(). */
     conversationJson: string;
     title?: string;

package/dist/session.js

@@ -89,6 +89,10 @@ export function parseSessionFile(path) {
     const messages = [];
     let title;
     let model;
+    /** Index in `messages` of the newest compaction summary, or -1. */
+    let lastCompactIndex = -1;
+    /** Newest API-reported input size, if the transcript carries usage. */
+    let reportedInputTokens;
     for (const line of raw.split("\n")) {
         if (!line.trim())
             continue;
@@ -113,13 +117,28 @@ export function parseSessionFile(path) {
             continue;
         if (typeof message.model === "string")
             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);
+            if (total > 0)
+                reportedInputTokens = total;
+        }
+        if (entry.isCompactSummary)
+            lastCompactIndex = messages.length;
         messages.push({ role: message.role, content: message.content });
     }
+    // A compaction replaces everything before it: the summary entry IS the live
+    // history from that point on. Counting the pre-compaction turns would
+    // overstate context, cost per message and window fill — sometimes hugely.
+    const compactedAway = lastCompactIndex >= 0 ? lastCompactIndex : 0;
+    const live = lastCompactIndex >= 0 ? messages.slice(lastCompactIndex) : messages;
     return {
-        conversationJson: JSON.stringify({ messages }),
+        conversationJson: JSON.stringify({ messages: live }),
         title,
         model,
-        messageCount: messages.length,
+        messageCount: live.length,
+        compactedAway,
+        reportedInputTokens,
         path,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-doctor",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "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",
@@ -30,6 +30,7 @@
   },
   "files": [
     "dist",
+    "!dist/test",
     "skills",
     "README.md",
     "LICENSE"
@@ -41,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/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"
+    "test": "npm run build && node --test dist/test/smoke.test.js dist/test/proxy.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"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",

package/dist/test/chatgpt-export.test.d.ts

@@ -1,2 +0,0 @@
-/** session: ChatGPT data-export (conversations.json) parsing. */
-export {};

package/dist/test/chatgpt-export.test.js

@@ -1,45 +0,0 @@
-/** session: ChatGPT data-export (conversations.json) parsing. */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseSessionFile } from "../session.js";
-function node(id, role, text, t) {
-    return [id, { id, message: { author: { role }, content: { content_type: "text", parts: [text] }, create_time: t } }];
-}
-const older = {
-    title: "Older chat",
-    update_time: 100,
-    default_model_slug: "gpt-4o",
-    mapping: Object.fromEntries([node("a", "user", "old question", 1)]),
-};
-const newer = {
-    title: "Trip planning",
-    update_time: 200,
-    default_model_slug: "gpt-5",
-    mapping: Object.fromEntries([
-        node("r", "system", "You are helpful.", 1),
-        node("x", "user", "Plan me a trip to Japan with a detailed itinerary please.", 2),
-        node("y", "assistant", "Day 1: Tokyo. Day 2: Kyoto. Day 3: Osaka with food tour.", 3),
-        ["tool-node", { id: "tool-node", message: { author: { role: "tool" }, content: { content_type: "text", parts: ["ignored"] }, create_time: 4 } }],
-    ]),
-};
-test("parses a ChatGPT export: newest conversation, ordered messages, model detected", () => {
-    const dir = mkdtempSync(join(tmpdir(), "ctxdoc-gpt-"));
-    const file = join(dir, "conversations.json");
-    writeFileSync(file, JSON.stringify([older, newer]));
-    const parsed = parseSessionFile(file);
-    assert.equal(parsed.title, "Trip planning");
-    assert.equal(parsed.model, "gpt-5");
-    assert.equal(parsed.messageCount, 3); // tool node excluded
-    const conv = JSON.parse(parsed.conversationJson);
-    assert.equal(conv.messages[0].role, "system");
-    assert.equal(conv.messages[1].content.includes("Japan"), true);
-});
-test("JSONL transcripts still parse (no regression)", () => {
-    const dir = mkdtempSync(join(tmpdir(), "ctxdoc-jsonl-"));
-    const file = join(dir, "s.jsonl");
-    writeFileSync(file, JSON.stringify({ type: "user", message: { role: "user", content: "hi" } }) + "\n");
-    assert.equal(parseSessionFile(file).messageCount, 1);
-});

package/dist/test/config.test.d.ts

@@ -1,2 +0,0 @@
-/** Project config discovery + context budget verdicts. */
-export {};

package/dist/test/config.test.js

@@ -1,64 +0,0 @@
-/** Project config discovery + context budget verdicts. */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { checkBudget, loadConfig, RC_FILENAME } from "../config.js";
-const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "cli.js");
-test("loadConfig walks up to the nearest .contextdoctorrc", () => {
-    const root = mkdtempSync(join(tmpdir(), "ctxdoc-cfg-"));
-    const nested = join(root, "packages", "app", "src");
-    mkdirSync(nested, { recursive: true });
-    writeFileSync(join(root, RC_FILENAME), JSON.stringify({ budget: { maxTokens: 1234 } }));
-    const loaded = loadConfig(nested);
-    assert.equal(loaded.config.budget?.maxTokens, 1234);
-    assert.equal(loaded.path, join(root, RC_FILENAME));
-});
-test("a malformed rc warns instead of throwing", () => {
-    const root = mkdtempSync(join(tmpdir(), "ctxdoc-cfg-bad-"));
-    writeFileSync(join(root, RC_FILENAME), "{ not json");
-    const warnings = [];
-    const loaded = loadConfig(root, (m) => warnings.push(m));
-    assert.deepEqual(loaded.config, {});
-    assert.equal(warnings.length, 1);
-});
-test("checkBudget flags each configured limit independently", () => {
-    const profile = { totalTokens: 200_000, usagePct: 65, cost: { perCallUsd: 1.2 } };
-    assert.equal(checkBudget(undefined, profile).overBudget, false);
-    assert.equal(checkBudget({}, profile).overBudget, false);
-    const tokens = checkBudget({ maxTokens: 100_000 }, profile);
-    assert.equal(tokens.overBudget, true);
-    assert.match(tokens.breaches[0], /over the 100000 budget/);
-    const cost = checkBudget({ maxCostPerMessageUsd: 0.5 }, profile);
-    assert.match(cost.breaches[0], /per message/);
-    const window = checkBudget({ maxWindowPct: 50 }, profile);
-    assert.match(window.breaches[0], /% of the window/);
-    const all = checkBudget({ maxTokens: 100_000, maxCostPerMessageUsd: 0.5, maxWindowPct: 50 }, profile);
-    assert.equal(all.breaches.length, 3);
-    const within = checkBudget({ maxTokens: 500_000, maxWindowPct: 90 }, profile);
-    assert.equal(within.overBudget, false);
-});
-test("analyze reports budget status from the project rc", async () => {
-    const root = mkdtempSync(join(tmpdir(), "ctxdoc-cfg-cli-"));
-    writeFileSync(join(root, RC_FILENAME), JSON.stringify({ budget: { maxTokens: 10 } }));
-    const chat = join(root, "chat.json");
-    writeFileSync(chat, JSON.stringify({ messages: [{ role: "user", content: "a fairly long message ".repeat(40) }] }));
-    const out = await new Promise((resolve, reject) => {
-        execFile(process.execPath, [cliPath, "analyze", chat, "--model", "claude-sonnet-5"], { cwd: root }, (err, stdout) => err ? reject(err) : resolve(stdout));
-    });
-    assert.ok(out.includes("OVER BUDGET"), `expected budget breach in output:\n${out}`);
-    assert.ok(out.includes(RC_FILENAME), "names the rc file responsible");
-});
-test("analyze stays quiet about budgets when no rc exists", async () => {
-    const root = mkdtempSync(join(tmpdir(), "ctxdoc-cfg-none-"));
-    const chat = join(root, "chat.json");
-    writeFileSync(chat, JSON.stringify({ messages: [{ role: "user", content: "hello" }] }));
-    const out = await new Promise((resolve, reject) => {
-        // HOME override keeps a real ~/.contextdoctorrc from leaking into the test.
-        execFile(process.execPath, [cliPath, "analyze", chat], { cwd: root, env: { ...process.env, HOME: root } }, (err, stdout) => err ? reject(err) : resolve(stdout));
-    });
-    assert.ok(!out.includes("BUDGET"), "no budget chatter without an rc");
-});

package/dist/test/dashboard.test.d.ts

@@ -1,2 +0,0 @@
-/** Dashboard: local-only server, real data shape, self-contained page. */
-export {};

package/dist/test/dashboard.test.js

@@ -1,37 +0,0 @@
-/** Dashboard: local-only server, real data shape, self-contained page. */
-import { test, after } from "node:test";
-import assert from "node:assert/strict";
-import { startDashboard, collectDashboardData } from "../dashboard.js";
-const server = startDashboard({ port: 0 });
-await new Promise((r) => server.once("listening", () => r()));
-const port = server.address().port;
-after(() => server.close());
-test("binds loopback only", () => {
-    assert.equal(server.address().address, "127.0.0.1");
-});
-test("/api/data returns the documented shape", async () => {
-    const data = (await (await fetch(`http://127.0.0.1:${port}/api/data`)).json());
-    for (const key of ["generatedAt", "totals", "daily", "sessions", "proxy", "budget"]) {
-        assert.ok(key in data, `missing ${key}`);
-    }
-    for (const key of ["tokensSaved", "usdSaved", "checks", "warnings", "optimizeRuns"]) {
-        assert.equal(typeof data.totals[key], "number", `totals.${key} must be numeric`);
-    }
-    assert.ok(Array.isArray(data.daily) && Array.isArray(data.sessions));
-});
-test("page is self-contained: no external requests", async () => {
-    const html = await (await fetch(`http://127.0.0.1:${port}/`)).text();
-    assert.ok(html.startsWith("<!doctype html>"));
-    // Only same-origin data fetch; nothing pulled from the network.
-    assert.ok(!/https?:\/\//.test(html.replace(/http:\/\/127\.0\.0\.1/g, "")), "page must not reference remote origins");
-    assert.ok(html.includes("/api/data"));
-    // Accessibility affordances required by the house chart rules.
-    assert.ok(html.includes("Table view"), "table view present");
-    assert.ok(html.includes('role="img"') || html.includes("aria-label"), "charts labelled");
-    assert.ok(html.includes("prefers-color-scheme: dark"), "dark mode selected, not flipped");
-});
-test("collectDashboardData works without a proxy running", async () => {
-    const data = await collectDashboardData(59999); // nothing listens here
-    assert.equal(data.proxy, null);
-    assert.ok(data.totals.tokensSaved >= 0);
-});

package/dist/test/doctor.test.d.ts

@@ -1,2 +0,0 @@
-/** doctor must always produce a diagnosis and exit 0, even on a bare machine. */
-export {};

package/dist/test/doctor.test.js

@@ -1,19 +0,0 @@
-/** doctor must always produce a diagnosis and exit 0, even on a bare machine. */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "cli.js");
-test("doctor runs, checks the MCP handshake, and exits 0", async () => {
-    const stateDir = mkdtempSync(join(tmpdir(), "ctxdoc-doctor-"));
-    const out = await new Promise((resolve, reject) => {
-        execFile(process.execPath, [cliPath, "doctor"], { env: { ...process.env, CONTEXT_DOCTOR_HOOK_STATE: join(stateDir, "state.json") }, timeout: 20000 }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
-    });
-    assert.ok(out.includes("CONTEXT DOCTOR — self-check"));
-    assert.ok(out.includes("MCP server handshake"));
-    assert.ok(/✓ MCP server handshake/.test(out), "our own server must pass its own handshake");
-    assert.ok(out.includes("Ledger"));
-});

package/dist/test/hook.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Hook tests: the every-prompt Claude Code hook must stay silent on lean
- * sessions, fire with guidance on heavy ones, and rate-limit re-fires.
- */
-export {};

package/dist/test/hook.test.js

@@ -1,54 +0,0 @@
-/**
- * Hook tests: the every-prompt Claude Code hook must stay silent on lean
- * sessions, fire with guidance on heavy ones, and rate-limit re-fires.
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "cli.js");
-const dir = mkdtempSync(join(tmpdir(), "ctxdoc-hook-"));
-const statePath = join(dir, "state.json");
-function transcriptLine(role, content) {
-    return JSON.stringify({ type: role, message: { role, content } });
-}
-function runHook(transcriptPath, sessionId) {
-    return new Promise((resolve, reject) => {
-        const child = execFile(process.execPath, [cliPath, "hook"], { env: { ...process.env, CONTEXT_DOCTOR_HOOK_STATE: statePath } }, (err, stdout) => (err ? reject(err) : resolve(stdout)));
-        child.stdin.end(JSON.stringify({ session_id: sessionId, transcript_path: transcriptPath }));
-    });
-}
-// Lean session: a couple of small turns.
-const leanPath = join(dir, "lean.jsonl");
-writeFileSync(leanPath, [transcriptLine("user", "hi"), transcriptLine("assistant", "hello!")].join("\n"));
-// Heavy session: ~100k tokens of transcript.
-const heavyPath = join(dir, "heavy.jsonl");
-const bigTurn = "We discussed the deployment pipeline and database migrations at length. ".repeat(80);
-writeFileSync(heavyPath, Array.from({ length: 300 }, (_, i) => transcriptLine(i % 2 ? "assistant" : "user", bigTurn)).join("\n"));
-test("hook stays silent on a lean session", async () => {
-    const out = await runHook(leanPath, "lean-session");
-    assert.equal(out.trim(), "");
-});
-test("hook fires with hygiene guidance on a heavy session", async () => {
-    const out = await runHook(heavyPath, "heavy-session");
-    const parsed = JSON.parse(out);
-    const ctx = parsed.hookSpecificOutput.additionalContext;
-    assert.equal(parsed.hookSpecificOutput.hookEventName, "UserPromptSubmit");
-    assert.ok(ctx.includes("<context-doctor>"));
-    assert.ok(/context is at ~\d/.test(ctx), "reports the measured size");
-    assert.ok(ctx.includes("context hygiene"));
-});
-test("hook rate-limits: second prompt in the same heavy session is silent", async () => {
-    const out = await runHook(heavyPath, "heavy-session");
-    assert.equal(out.trim(), "");
-});
-test("hook never errors on malformed input", async () => {
-    const out = await new Promise((resolve, reject) => {
-        const child = execFile(process.execPath, [cliPath, "hook"], (err, stdout) => err ? reject(err) : resolve(stdout));
-        child.stdin.end("this is not json");
-    });
-    assert.equal(out.trim(), "");
-});

package/dist/test/mcp-http.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * MCP streamable-HTTP transport: spawn `mcp.js --http`, run the initialize
- * handshake and a tool call over plain HTTP, exactly as a URL-based client
- * (e.g. a ChatGPT developer-mode connector) would.
- */
-export {};

package/dist/test/mcp-http.test.js

@@ -1,63 +0,0 @@
-/**
- * MCP streamable-HTTP transport: spawn `mcp.js --http`, run the initialize
- * handshake and a tool call over plain HTTP, exactly as a URL-based client
- * (e.g. a ChatGPT developer-mode connector) would.
- */
-import { test, after } from "node:test";
-import assert from "node:assert/strict";
-import { spawn } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const mcpPath = join(dirname(fileURLToPath(import.meta.url)), "..", "mcp.js");
-const PORT = 8898;
-const child = spawn(process.execPath, [mcpPath, "--http", "--port", String(PORT)], { stdio: ["ignore", "ignore", "pipe"] });
-await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error("HTTP MCP server did not start")), 8000);
-    child.stderr.on("data", (d) => {
-        if (d.toString().includes("streamable HTTP")) {
-            clearTimeout(timer);
-            resolve();
-        }
-    });
-});
-after(() => child.kill());
-async function rpc(body) {
-    const res = await fetch(`http://127.0.0.1:${PORT}/mcp`, {
-        method: "POST",
-        headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
-        body: JSON.stringify(body),
-    });
-    const text = await res.text();
-    // Streamable HTTP may answer as SSE ("data: {...}") or plain JSON.
-    const dataLine = text.split("\n").find((l) => l.startsWith("data: "));
-    return { status: res.status, json: JSON.parse(dataLine ? dataLine.slice(6) : text) };
-}
-test("initialize over HTTP returns server info + instructions", async () => {
-    const { status, json } = await rpc({
-        jsonrpc: "2.0",
-        id: 1,
-        method: "initialize",
-        params: { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "t", version: "1" } },
-    });
-    assert.equal(status, 200);
-    assert.equal(json.result.serverInfo.name, "context-doctor");
-    assert.ok(json.result.instructions.includes("Context hygiene"));
-});
-test("tools/call works statelessly over HTTP", async () => {
-    const { json } = await rpc({
-        jsonrpc: "2.0",
-        id: 2,
-        method: "tools/call",
-        params: {
-            name: "profile_context",
-            arguments: { conversation: JSON.stringify({ messages: [{ role: "user", content: "hello world" }] }) },
-        },
-    });
-    assert.ok(json.result.content[0].text.includes("CONTEXT DOCTOR"));
-});
-test("health endpoint responds; non-POST is rejected", async () => {
-    const health = (await (await fetch(`http://127.0.0.1:${PORT}/health`)).json());
-    assert.equal(health.ok, true);
-    const get = await fetch(`http://127.0.0.1:${PORT}/mcp`);
-    assert.equal(get.status, 405);
-});

package/dist/test/proxy.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Proxy end-to-end test against a mock upstream: verifies in-flight
- * optimization, tool_result preservation, header passthrough, SSE-style
- * streaming, and the /stats endpoint.
- */
-export {};

package/dist/test/proxy.test.js

@@ -1,121 +0,0 @@
-/**
- * Proxy end-to-end test against a mock upstream: verifies in-flight
- * optimization, tool_result preservation, header passthrough, SSE-style
- * streaming, and the /stats endpoint.
- */
-import { test, after } from "node:test";
-import assert from "node:assert/strict";
-import http from "node:http";
-import { startProxy } from "../proxy.js";
-const bigTool = "row of data | ".repeat(2000);
-const doc = "TERMS: usage is billed monthly per seat with overage charged at cycle end. ".repeat(8);
-const payload = JSON.stringify({
-    model: "claude-sonnet-5",
-    max_tokens: 100,
-    system: "You are helpful.",
-    messages: [
-        { role: "user", content: "check the data\n" + doc },
-        { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "query_db", input: { q: "select *" } }] },
-        { role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: bigTool }] },
-        { role: "assistant", content: "Done." },
-        { role: "user", content: "check the data\n" + doc },
-        ...Array.from({ length: 7 }, (_, i) => ({ role: "user", content: `follow-up ${i}` })),
-    ],
-});
-let received = "";
-let receivedApiKey;
-const upstream = http.createServer((req, res) => {
-    let body = "";
-    req.on("data", (c) => (body += c));
-    req.on("end", () => {
-        received = body;
-        receivedApiKey = req.headers["x-api-key"];
-        res.writeHead(200, { "content-type": "text/event-stream" });
-        res.write("event: message_start\ndata: {}\n\n");
-        res.write('event: message_delta\ndata: {"usage":{"input_tokens":120,"output_tokens":45}}\n\n');
-        res.write("event: message_stop\ndata: {}\n\n");
-        res.end();
-    });
-});
-await new Promise((r) => upstream.listen(0, r));
-const upstreamPort = upstream.address().port;
-const proxy = startProxy({ port: 0, anthropicUpstream: `http://localhost:${upstreamPort}` });
-await new Promise((r) => proxy.once("listening", () => r()));
-const proxyPort = proxy.address().port;
-after(() => {
-    proxy.close();
-    upstream.close();
-});
-test("proxy optimizes in flight and passes through auth + streaming", async () => {
-    const resp = await fetch(`http://localhost:${proxyPort}/v1/messages`, {
-        method: "POST",
-        headers: { "content-type": "application/json", "x-api-key": "sk-test-not-real", "anthropic-version": "2023-06-01" },
-        body: payload,
-    });
-    const respText = await resp.text();
-    assert.ok(received.length < payload.length, "upstream received a smaller body");
-    const parsed = JSON.parse(received);
-    const toolBlock = parsed.messages[2].content[0];
-    assert.equal(toolBlock.type, "tool_result");
-    assert.equal(toolBlock.tool_use_id, "t1");
-    assert.equal(parsed.model, "claude-sonnet-5");
-    assert.equal(receivedApiKey, "sk-test-not-real");
-    assert.equal(resp.status, 200);
-    assert.ok(respText.includes("message_start") && respText.includes("message_stop"), "SSE streamed through");
-});
-test("/stats reports cumulative savings with dollar estimate", async () => {
-    const stats = await (await fetch(`http://localhost:${proxyPort}/stats`)).json();
-    assert.equal(stats.requests, 1);
-    assert.equal(stats.optimizedRequests, 1);
-    assert.ok(stats.tokensSaved > 1000, `saved tokens tracked (${stats.tokensSaved})`);
-    assert.ok(stats.estUsdSaved > 0, "dollar savings estimated from the request's model");
-});
-test("response usage is captured from the SSE stream; cache advisor fires on prefix churn", async () => {
-    // Second request with a DIFFERENT system prompt on the same model → advisory.
-    const churned = JSON.parse(payload);
-    churned.system = "You are helpful. TODAY IS A NEW DAY."; // classic cache-buster
-    churned.tools = [{ name: "t", description: "x".repeat(5000), input_schema: { type: "object" } }];
-    const first = JSON.parse(payload);
-    first.tools = churned.tools;
-    for (const body of [first, churned]) {
-        await fetch(`http://localhost:${proxyPort}/v1/messages`, {
-            method: "POST",
-            headers: { "content-type": "application/json", "x-api-key": "sk-test-not-real" },
-            body: JSON.stringify(body),
-        });
-    }
-    const stats = (await (await fetch(`http://localhost:${proxyPort}/stats`)).json());
-    // Mock upstream reports usage in its SSE close event (added below).
-    assert.ok(stats.upstreamInputTokens >= 100, `usage input captured: ${stats.upstreamInputTokens}`);
-    assert.ok(stats.upstreamOutputTokens >= 40, `usage output captured: ${stats.upstreamOutputTokens}`);
-    assert.ok(stats.advice.some((a) => a.includes("prefix changed")), `prefix-churn advisory expected, got: ${JSON.stringify(stats.advice)}`);
-    assert.ok(stats.advice.some((a) => a.includes("cache_control")), "missing-cache_control advisory expected");
-});
-test("per-route config: empty strategy list disables optimization for matching models", async () => {
-    const { startProxy } = await import("../proxy.js");
-    const routed = startProxy({
-        port: 0,
-        anthropicUpstream: `http://localhost:${upstreamPort}`,
-        routes: [{ modelPrefix: "claude-sonnet", strategies: [] }],
-    });
-    await new Promise((r) => routed.once("listening", () => r()));
-    const routedPort = routed.address().port;
-    try {
-        const sent = payload;
-        await fetch(`http://localhost:${routedPort}/v1/messages`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: sent,
-        });
-        assert.equal(received.length, sent.length, "route with no strategies must pass body through unmodified");
-    }
-    finally {
-        routed.close();
-    }
-});
-test("unsupported paths get a clear 404, health stays up", async () => {
-    const notFound = await fetch(`http://localhost:${proxyPort}/v1/nope`, { method: "POST", body: "{}" });
-    assert.equal(notFound.status, 404);
-    const health = await (await fetch(`http://localhost:${proxyPort}/health`)).json();
-    assert.equal(health.ok, true);
-});

package/dist/test/smoke.test.d.ts

@@ -1,2 +0,0 @@
-/** Smoke tests: parse → profile → optimize roundtrip for both provider formats. */
-export {};

package/dist/test/smoke.test.js

@@ -1,111 +0,0 @@
-/** Smoke tests: parse → profile → optimize roundtrip for both provider formats. */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { parseConversation } from "../parse.js";
-import { profileConversation } from "../profile.js";
-import { optimizeConversation } from "../optimize.js";
-// Large enough to clear the profiler's 2000-token oversized-tool-result threshold.
-const bigText = "Sunny, 18C. ".repeat(900);
-const openaiConv = JSON.stringify({
-    messages: [
-        { role: "system", content: "You are helpful." },
-        { role: "user", content: "weather in SF?" },
-        { role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "get_weather", arguments: '{"city":"SF"}' } }] },
-        { role: "tool", tool_call_id: "c1", content: bigText },
-        { role: "assistant", content: "It is sunny and 18C in SF." },
-    ],
-});
-const anthropicConv = JSON.stringify({
-    system: "You are helpful.",
-    messages: [
-        { role: "user", content: "weather in SF?" },
-        { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "get_weather", input: { city: "SF" } }] },
-        { role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: bigText }] },
-        { role: "assistant", content: "Sunny and 18C." },
-    ],
-});
-test("parses OpenAI format and classifies tool plumbing", () => {
-    const conv = parseConversation(openaiConv);
-    assert.equal(conv.sourceFormat, "openai");
-    assert.equal(conv.messages.filter((m) => m.kind === "tool_result").length, 1);
-    assert.equal(conv.messages.filter((m) => m.kind === "tool_call").length, 1);
-});
-test("parses Anthropic format including external system prompt", () => {
-    const conv = parseConversation(anthropicConv);
-    assert.equal(conv.sourceFormat, "anthropic");
-    assert.equal(conv.messages[0].kind, "system");
-    assert.ok(conv.messages.some((m) => m.toolName === "get_weather"));
-});
-test("profiler flags oversized tool results", () => {
-    const profile = profileConversation(parseConversation(openaiConv), "gpt-4o");
-    assert.ok(profile.totalTokens > 500);
-    assert.equal(profile.contextWindow, 128_000);
-    assert.ok(profile.findings.some((f) => f.id === "large_tool_result"));
-});
-test("optimizer trims stale tool results and reports savings", () => {
-    const result = optimizeConversation(openaiConv, { keepRecent: 1, maxToolResultTokens: 50 });
-    assert.ok(result.tokensAfter < result.tokensBefore);
-    assert.ok(result.applied.some((c) => c.strategy === "trim-tool-results"));
-    // Output must remain valid JSON with the same message count.
-    const out = result.conversation;
-    assert.equal(out.messages.length, 5);
-});
-test("optimizer output for Anthropic format keeps block structure valid", () => {
-    const result = optimizeConversation(anthropicConv, { keepRecent: 1, maxToolResultTokens: 50 });
-    const out = result.conversation;
-    for (const m of out.messages) {
-        assert.ok(typeof m.content === "string" || Array.isArray(m.content));
-    }
-    // The trimmed tool_result must KEEP its block type and tool_use_id — the
-    // Anthropic API rejects a tool_use with no matching tool_result.
-    const toolResultMsg = out.messages[2].content;
-    assert.equal(toolResultMsg[0].type, "tool_result");
-    assert.equal(toolResultMsg[0].tool_use_id, "t1");
-    assert.ok(toolResultMsg[0].content.length < 1000, "tool_result content was trimmed");
-    // And the tool_use block on the assistant side is untouched.
-    const assistantMsg = out.messages[1].content;
-    assert.equal(assistantMsg[0].type, "tool_use");
-});
-test("prune-history never leaves an orphaned tool result at the head of the tail", () => {
-    // Build a conversation where the naive prune boundary would land exactly on
-    // a tool-result message (its tool_use call falling in the pruned half).
-    const filler = "some earlier discussion that will be pruned away. ".repeat(20);
-    const conv = JSON.stringify({
-        messages: [
-            ...Array.from({ length: 8 }, (_, i) => ({ role: i % 2 ? "assistant" : "user", content: `${i} ${filler}` })),
-            { role: "assistant", content: [{ type: "tool_use", id: "tX", name: "search", input: { q: "x" } }] },
-            { role: "user", content: [{ type: "tool_result", tool_use_id: "tX", content: "results here" }] }, // naive boundary lands HERE
-            { role: "assistant", content: "Summary of results." },
-            { role: "user", content: "thanks" },
-            { role: "assistant", content: "welcome" },
-        ],
-    });
-    const result = optimizeConversation(conv, { strategies: ["prune-history"], keepRecent: 4 });
-    const out = result.conversation;
-    // First kept message after the stub must NOT be a tool result.
-    const firstKept = out.messages[1].content;
-    const isToolResult = Array.isArray(firstKept) && firstKept.some((b) => b?.type === "tool_result");
-    assert.equal(isToolResult, false, "tail must not start with an orphaned tool_result");
-    assert.ok(result.applied.some((c) => c.strategy === "prune-history"), "pruning still happened");
-});
-test("near-duplicate detection catches same doc with different lead-ins", () => {
-    // Varied clauses (not a repeated sentence) — like a real document.
-    const doc = Array.from({ length: 30 }, (_, i) => `Clause ${i} of the pricing policy covers refund scenario ${i} where the customer holds receipt series ${i * 7} under regional rule ${i % 5}.`).join(" ");
-    const conv = JSON.stringify({
-        messages: [
-            { role: "user", content: "Here is our policy document for you to review:\n" + doc },
-            { role: "assistant", content: "Understood, thanks for sharing the policy." },
-            { role: "user", content: "Sharing the policy doc again with a totally different intro so exact hashing misses it:\n" + doc },
-        ],
-    });
-    const profile = profileConversation(parseConversation(conv));
-    const near = profile.findings.find((f) => f.id === "near_duplicate");
-    assert.ok(near, "near_duplicate finding expected");
-    assert.deepEqual(near.messages, [0, 2]);
-    assert.ok(near.estSavings > 50);
-});
-test("raw text input still profiles", () => {
-    const profile = profileConversation(parseConversation("just some prompt text"));
-    assert.equal(profile.messageCount, 1);
-    assert.ok(profile.totalTokens > 0);
-});

package/dist/test/watch.test.d.ts

@@ -1,2 +0,0 @@
-/** watch: emits a status line on growth, surfaces new findings once. */
-export {};

package/dist/test/watch.test.js

@@ -1,36 +0,0 @@
-/** watch: emits a status line on growth, surfaces new findings once. */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { spawn } from "node:child_process";
-import { appendFileSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "cli.js");
-function line(role, content) {
-    return JSON.stringify({ type: role, message: { role, content } }) + "\n";
-}
-test("watch reports growth and new findings live", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "ctxdoc-watch-"));
-    const file = join(dir, "trace.jsonl");
-    writeFileSync(file, line("user", "hello there"));
-    const child = spawn(process.execPath, [cliPath, "watch", file, "--interval-ms", "150"], { stdio: ["ignore", "pipe", "pipe"] });
-    let out = "";
-    child.stdout.on("data", (d) => (out += d.toString()));
-    try {
-        // First tick: initial line.
-        await new Promise((r) => setTimeout(r, 500));
-        assert.ok(/tokens/.test(out), `initial status line expected, got: ${out}`);
-        // Grow the file with an oversized tool result → new status + a finding.
-        appendFileSync(file, line("assistant", JSON.stringify([{ type: "tool_use", id: "t1", name: "search", input: {} }])) +
-            JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "tool_result", tool_use_id: "t1", content: "data ".repeat(3000) }] } }) +
-            "\n");
-        await new Promise((r) => setTimeout(r, 700));
-        const statusLines = out.split("\n").filter((l) => l.includes("tokens"));
-        assert.ok(statusLines.length >= 2, `expected a second status line after growth: ${out}`);
-        assert.ok(out.includes("⚠"), `expected a finding to surface: ${out}`);
-    }
-    finally {
-        child.kill();
-    }
-});