context-doctor 0.7.0 → 0.9.0

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.7.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"
+    "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/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();
-    }
-});