context-doctor 0.8.0 → 0.10.0

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.10.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.d.ts

@@ -12,7 +12,7 @@ export interface MessageProfile {
     preview: string;
     toolName?: string;
 }
-export type FindingId = "large_tool_result" | "duplicate_content" | "near_duplicate" | "repeated_tool_call" | "base64_blob" | "long_history" | "large_system_prompt" | "cache_ordering" | "near_window_limit";
+export type FindingId = "large_tool_result" | "duplicate_content" | "near_duplicate" | "repeated_tool_call" | "repeated_file_read" | "retained_error_output" | "base64_blob" | "long_history" | "large_system_prompt" | "cache_ordering" | "near_window_limit";
 export interface Finding {
     id: FindingId;
     severity: "info" | "warn" | "high";

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;
@@ -160,6 +194,58 @@ export function profileConversation(conv, model) {
             });
         }
     }
+    // -- Same file read again and again -----------------------------------------
+    // The dominant waste in agent loops: a file re-read because its earlier
+    // contents scrolled out of attention, leaving several full copies in context.
+    {
+        const readsByPath = new Map();
+        for (const p of perMessage) {
+            if (p.msg.kind !== "tool_call" || !p.msg.toolCallText)
+                continue;
+            if (!/read|open|cat|view|get_file/i.test(p.msg.toolName ?? ""))
+                continue;
+            const match = /"(?:file_path|filePath|path|file)"\s*:\s*"([^"]{3,})"/.exec(p.msg.toolCallText);
+            if (!match)
+                continue;
+            const path = match[1];
+            readsByPath.set(path, [...(readsByPath.get(path) ?? []), p.msg.index]);
+        }
+        for (const [path, indexes] of readsByPath) {
+            if (indexes.length < 3)
+                continue;
+            // Each re-read pulls the file in again; all but the last are recoverable.
+            const resultTokens = perMessage
+                .filter((p) => p.msg.kind === "tool_result" && indexes.some((i) => p.msg.index === i + 1))
+                .reduce((sum, p) => sum + p.tokens, 0);
+            const savings = Math.round((resultTokens * (indexes.length - 1)) / indexes.length);
+            findings.push({
+                id: "repeated_file_read",
+                severity: savings > 4000 ? "high" : "warn",
+                estSavings: savings,
+                message: `${path.split("/").pop()} was read ${indexes.length} times (messages #${indexes.join(", #")}), keeping ${indexes.length} copies in context.`,
+                suggestion: "Re-read a file only after it changes; otherwise refer back to the copy already in context.",
+                messages: indexes,
+            });
+        }
+    }
+    // -- Failed tool output kept verbatim ---------------------------------------
+    // Stack traces and command failures are read once and never again, yet they
+    // are often the largest blocks in an agent transcript.
+    for (const p of perMessage) {
+        if (p.msg.kind !== "tool_result" || p.tokens < 500)
+            continue;
+        const looksFailed = /Traceback \(most recent call last\)|command not found|npm error|ERR!|\bexit code [1-9]|Exception in thread|FAILED|error TS\d+/i.test(p.msg.text);
+        if (!looksFailed)
+            continue;
+        findings.push({
+            id: "retained_error_output",
+            severity: "warn",
+            estSavings: Math.round(p.tokens * 0.85),
+            message: `Message #${p.msg.index} holds ~${p.tokens} tokens of failed tool output (errors, stack trace or non-zero exit).`,
+            suggestion: "Keep the one line that identifies the failure and drop the rest — a full trace has no value once the fix is understood.",
+            messages: [p.msg.index],
+        });
+    }
     // -- Base64 / binary blobs ---------------------------------------------------
     for (const p of perMessage) {
         if (BASE64_RE.test(p.msg.text)) {
@@ -235,7 +321,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.10.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 dist/test/cache.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 {};