context-doctor 0.28.0 → 0.29.0

package/README.md

@@ -25,6 +25,7 @@ Pick where you work. Each takes about a minute and is fully reversible.
 | **Claude Desktop, Cursor or any MCP client** | Add the server to the client's MCP config (or install the one-click `.mcpb` from the [latest release](https://github.com/KushalP1/context-doctor/releases/latest) in Claude Desktop):<br>`{"mcpServers": {"context-doctor": {"command": "npx", "args": ["-y", "context-doctor", "mcp"]}}}` |
 | **claude.ai, ChatGPT, phone apps** | `npx context-doctor instructions --copy`, then paste into the app's personal preferences |
 | **Your own app on an LLM API** | Run `npx context-doctor proxy --autopilot` and point `ANTHROPIC_BASE_URL`, `OPENAI_BASE_URL` (add `/v1`) or `GOOGLE_GEMINI_BASE_URL` at `http://localhost:8787`. No proxy possible? Wrap the SDK client: `withContextDoctor(new Anthropic())` |
+| **Python / RAG pipelines** | `pip install context-doctor` (after the first PyPI release; until then `pip install "git+https://github.com/KushalP1/context-doctor#subdirectory=python"`), then `pack_documents(retrieved_docs, question, budget=4000)` trims LangChain or LlamaIndex results to the chunks that matter. [Python README](./python/README.md) |
 | **GitHub pull requests** | `uses: KushalP1/context-doctor@v0.27.0` comments how much a PR grows CLAUDE.md, AGENTS.md and rules, and can fail over a budget ([setup](#enforce-a-budget-in-ci)) |
 
 ## What it does
@@ -32,6 +33,8 @@ Pick where you work. Each takes about a minute and is fully reversible.
 **Measure, in dollars, on your own history**
 - `savings`: what your recent Claude Code sessions cost and what each fix below would have saved, replayed request by request against what you were billed.
 - `overhead`: what every request re-reads before your message (system prompt, tools, MCP servers, CLAUDE.md, rules, memory), each file priced per month.
+- `tasks`: cost per commit, per project, from each session's recorded usage and its own `git commit` calls.
+- `reads`: the files read into session after session, and whether a CLAUDE.md summary or `pack` would pay.
 - `session`, `watch`, `analyze`, `report`, `dashboard`: token breakdown and wasted-context findings for any session, conversation file or agent trace.
 
 **Keep waste out of the context**
@@ -174,6 +177,7 @@ MCP servers are part of the same overhead: each one's tool definitions ride on e
 
 ## What's new
 
+- **0.29 Python, and where the work goes**: a dependency-free Python package (`python/`) with `pack_documents` for LangChain and LlamaIndex results, `pack_context`, `estimate_tokens` and `profile_messages`, held byte for byte to the TypeScript by parity tests. `context-doctor reads` shows the files read into session after session; `context-doctor tasks` shows cost per commit per project, from your own transcripts.
 - **0.28 Wider reach**: `/context-doctor:overhead` and `/context-doctor:pack` in the Claude Code plugin; `pack` reads a folder inside a git repository the way git does, so `.gitignore`'d build output and secrets stay out; `withContextDoctor` wraps Google's `@google/genai` client too; `overhead` measures the fixed start-of-session cost of Codex and Gemini CLI sessions as well as Claude Code's, priced with each provider's cache rules.
 - **0.27 Keep waste out**: `pack` and the `pack_context` MCP tool put only the chunks of big files (text, code, PDF, Word, PowerPoint) a question needs into the context, within a budget; `overhead` measures and prices the front matter every request re-reads (system prompt, tools, CLAUDE.md, rules, memory, AGENTS.md, Cursor rules, GEMINI.md). MCP servers sized and their use counted; `overhead split` turns a heavy memory file into a lean one plus a reference file. `withContextDoctor(client)` runs autopilot inside an Anthropic or OpenAI SDK client, for apps with no proxy. Gemini joins: `install` wires Gemini CLI's MCP server and every-prompt hook, `session` and `watch` read its chats, and the proxy and autopilot carry Google's Gemini API. A GitHub Action (and `context-doctor ci`) reports memory-file growth on every pull request and gates on a budget. Re-verified on every surface: 229 tests on macOS, Linux and Windows, plus MCP, OpenAI and Gemini end-to-end smoke runs, now in CI, MCP over stdio and HTTP, the OpenAI proxy, and a live `doctor`.
 - **0.26 Checked on every platform, three fixes**: tested end to end in Claude Code (terminal, desktop app, plugin from GitHub), Claude Desktop, Cursor, Codex on GPT-5.5, VS Code, the MCP server on every launch path, and the proxy on OpenAI's APIs. Found and fixed: Cursor's agent never received the hook's guidance (Cursor runs Claude Code's hook where output cannot add context), so `install` now adds a native Cursor hook; Codex blocked the MCP tools behind an approval it never grants in `codex exec`, so the tools are now marked read-only; autopilot skipped Codex's newest tools (`exec`, `wait`) and some of Cursor's. Also: a history imported into Codex no longer reads as "2136% of the window", and the chat-app settings paths are current.

package/dist/cli.js

@@ -45,6 +45,8 @@ import { packContextSemantic, readSources, renderPack } from "./pack.js";
 import { measureBaselines, measureMcpSizes, overheadReport, renderOverhead } from "./overhead.js";
 import { applySplit, planSplit, renderSplit } from "./split.js";
 import { ciReport, renderCiMarkdown, renderCiText } from "./ci.js";
+import { renderReads, repeatedReads } from "./reads.js";
+import { costPerTask, renderTasks } from "./tasks.js";
 const HELP = `context-doctor — profile and optimize LLM context windows
 
 Usage:
@@ -102,6 +104,10 @@ Usage:
   context-doctor ci [--base <ref>] [--max-tokens n] [--max-increase n] [--markdown]
                                                 For pull requests: memory files (CLAUDE.md, AGENTS.md,
                                                 GEMINI.md, rules) at HEAD vs base; exit 1 over budget
+  context-doctor tasks [--days n]               Cost per commit, per project: session cost at list
+                                                price vs commits made during the sessions
+  context-doctor reads [--days n] [--limit n]   Files read into session after session: reads, tokens,
+                                                cost, and whether a CLAUDE.md summary or pack pays
   context-doctor overhead split <file> [--write]
                                                 Move a memory file's big sections to a reference
                                                 file, leaving pointers (plan first; --write backs up)
@@ -711,6 +717,16 @@ async function main() {
         });
         return; // server keeps the process alive
     }
+    if (args.command === "tasks") {
+        const report = costPerTask(args.days ?? 30);
+        console.log(args.json ? JSON.stringify(report, null, 2) : renderTasks(report, args.limit ?? 12));
+        return;
+    }
+    if (args.command === "reads") {
+        const report = repeatedReads(args.days ?? 30);
+        console.log(args.json ? JSON.stringify(report, null, 2) : renderReads(report, args.limit ?? 15));
+        return;
+    }
     if (args.command === "ci") {
         const report = ciReport({ base: args.base, maxTokens: args.maxTokens, maxIncrease: args.maxIncrease });
         console.log(args.json ? JSON.stringify(report, null, 2) : args.markdown ? renderCiMarkdown(report, { model: args.model, requestsPerDay: args.requestsPerDay }) : renderCiText(report));

package/dist/index.d.ts

@@ -32,3 +32,5 @@ export * from "./split.js";
 export * from "./mcpschema.js";
 export * from "./wrap.js";
 export * from "./ci.js";
+export * from "./reads.js";
+export * from "./tasks.js";

package/dist/index.js

@@ -27,3 +27,5 @@ export * from "./split.js";
 export * from "./mcpschema.js";
 export * from "./wrap.js";
 export * from "./ci.js";
+export * from "./reads.js";
+export * from "./tasks.js";

package/dist/mcp.js

@@ -52,7 +52,7 @@ const STRATEGY_IDS = ["dedupe", "trim-tool-results", "trim-tool-calls", "strip-b
  * recommended pattern.
  */
 function createServer({ fileAccess = true } = {}) {
-    const server = new McpServer({ name: "context-doctor", version: "0.28.0" }, { instructions: SERVER_INSTRUCTIONS });
+    const server = new McpServer({ name: "context-doctor", version: "0.29.0" }, { instructions: SERVER_INSTRUCTIONS });
     server.tool("profile_context", "Profile an LLM conversation or prompt: token breakdown, largest blocks, and actionable findings about wasted context (duplicates, oversized pastes or tool results, base64 blobs, long history). Two inputs, pass ONE: `conversation` (full OpenAI/Anthropic JSON or raw text, for agents, files and proxies) or `sketch` (for chat apps such as Claude Desktop or ChatGPT where you cannot export the conversation: the turn count plus the few blocks that matter, ~120 tokens to write). Call it whenever the user asks about token usage, context size, cost, speed or limits, and on your own once the conversation passes ~30 turns or holds 3+ large pastes. Act on the top finding in your reply.", {
         conversation: z.string().optional().describe("Conversation JSON (OpenAI or Anthropic format, or bare message array) or raw prompt text. Omit in chat apps and pass `sketch`."),
         sketch: z.object({

package/dist/proxy.d.ts

@@ -48,7 +48,7 @@ export interface ProxyOptions extends OptimizeOptions {
     googleUpstream?: string;
 }
 /** Reported by /health so `autopilot status` can tell an outdated service from a current one. */
-export declare const PROXY_VERSION = "0.28.0";
+export declare const PROXY_VERSION = "0.29.0";
 /**
  * Remove a leading `/t/<token>` from a request path, or return undefined when
  * the prefix is absent or the token differs. The comparison is constant time

package/dist/proxy.js

@@ -20,7 +20,7 @@ import { formatTokens, CHARS_PER_TOKEN, providerFor } from "./tokens.js";
 import { formatUsd, inputCostUsd, pricingFor } from "./pricing.js";
 import { recordLedger } from "./ledger.js";
 /** Reported by /health so `autopilot status` can tell an outdated service from a current one. */
-export const PROXY_VERSION = "0.28.0";
+export const PROXY_VERSION = "0.29.0";
 /** Connection-level headers that must not be forwarded. */
 const SKIP_REQUEST_HEADERS = new Set(["host", "content-length", "connection", "transfer-encoding", "accept-encoding", "expect"]);
 const SKIP_RESPONSE_HEADERS = new Set(["content-length", "content-encoding", "transfer-encoding", "connection"]);

package/dist/reads.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `context-doctor reads`: the same files, read into session after session.
+ *
+ * Agents orient themselves by reading the same files at the start of most
+ * sessions: the README, the main module, a config. Each read is written into
+ * that session's context and re-read on every later request, and the next
+ * session pays for it again. This counts Read calls across recent Claude Code
+ * transcripts, groups them by file, and says per file whether a short summary
+ * in the project's CLAUDE.md would pay (read in most of the project's
+ * sessions) or not (CLAUDE.md is paid on every request, so an occasional read
+ * is cheaper left as a read; `pack` can cut it to the part a question needs).
+ */
+export interface RepeatedRead {
+    path: string;
+    project: string;
+    /** Sessions that read it at least once. */
+    sessions: number;
+    /** Sessions of that project in the period. */
+    projectSessions: number;
+    reads: number;
+    /** Tokens of all its results, summed over every read. */
+    tokens: number;
+    /** Floor of the cost: each read written to the prompt cache once (1.25x input). */
+    usd?: number;
+    advice: "summarize" | "pack";
+}
+export interface ReadsReport {
+    days: number;
+    sessions: number;
+    reads: number;
+    readTokens: number;
+    files: RepeatedRead[];
+}
+export declare function repeatedReads(days?: number, paths?: string[], minSessions?: number): ReadsReport;
+export declare function renderReads(r: ReadsReport, limit?: number, home?: string): string;

package/dist/reads.js

@@ -0,0 +1,151 @@
+/**
+ * `context-doctor reads`: the same files, read into session after session.
+ *
+ * Agents orient themselves by reading the same files at the start of most
+ * sessions: the README, the main module, a config. Each read is written into
+ * that session's context and re-read on every later request, and the next
+ * session pays for it again. This counts Read calls across recent Claude Code
+ * transcripts, groups them by file, and says per file whether a short summary
+ * in the project's CLAUDE.md would pay (read in most of the project's
+ * sessions) or not (CLAUDE.md is paid on every request, so an occasional read
+ * is cheaper left as a read; `pack` can cut it to the part a question needs).
+ */
+import { forEachLine, listSessions } from "./session.js";
+import { estimateTokens, formatTokens } from "./tokens.js";
+import { formatUsd, pricingFor } from "./pricing.js";
+const CLAUDE = "claude-opus-5";
+/** An image in a tool result bills as an image (~1.6k tokens for a full-size screenshot), not as its base64. */
+const IMAGE_TOKENS = 1600;
+function resultTokens(content) {
+    if (typeof content === "string")
+        return estimateTokens(content, CLAUDE);
+    if (!Array.isArray(content))
+        return estimateTokens(JSON.stringify(content ?? ""), CLAUDE);
+    let n = 0;
+    for (const part of content) {
+        if (part?.type === "image")
+            n += IMAGE_TOKENS;
+        else if (typeof part?.text === "string")
+            n += estimateTokens(part.text, CLAUDE);
+        else
+            n += estimateTokens(JSON.stringify(part ?? ""), CLAUDE);
+    }
+    return n;
+}
+/** Read calls in one transcript: path -> {reads, tokens}, plus the session's model and project directory. */
+function sessionReads(path) {
+    const pending = new Map();
+    const files = new Map();
+    let cwd;
+    let model;
+    forEachLine(path, (line) => {
+        if (!line.includes('"tool_use"') && !line.includes('"tool_result"') && cwd !== undefined)
+            return;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!e || e.isSidechain)
+            return;
+        if (!cwd && typeof e.cwd === "string")
+            cwd = e.cwd;
+        const content = e.message?.content;
+        if (!Array.isArray(content))
+            return;
+        if (e.type === "assistant") {
+            if (typeof e.message.model === "string")
+                model = e.message.model;
+            for (const b of content) {
+                if (b?.type === "tool_use" && b.name === "Read" && typeof b.input?.file_path === "string")
+                    pending.set(b.id, b.input.file_path);
+            }
+        }
+        else if (e.type === "user") {
+            for (const b of content) {
+                if (b?.type !== "tool_result")
+                    continue;
+                const file = pending.get(b.tool_use_id);
+                if (!file)
+                    continue;
+                pending.delete(b.tool_use_id);
+                const f = files.get(file) ?? { reads: 0, tokens: 0 };
+                f.reads++;
+                f.tokens += resultTokens(b.content);
+                files.set(file, f);
+            }
+        }
+    });
+    return { cwd, model, files };
+}
+export function repeatedReads(days = 30, paths, minSessions = 3) {
+    const since = Date.now() - days * 86_400_000;
+    const list = paths ?? listSessions(10_000).filter((s) => s.path.includes(".claude") && s.modifiedAt.getTime() >= since).map((s) => s.path);
+    const byFile = new Map();
+    const projectSessions = new Map();
+    let reads = 0, readTokens = 0;
+    for (const p of list) {
+        const s = sessionReads(p);
+        const project = s.cwd ?? "?";
+        projectSessions.set(project, (projectSessions.get(project) ?? 0) + 1);
+        const price = pricingFor(s.model);
+        for (const [file, f] of s.files) {
+            reads += f.reads;
+            readTokens += f.tokens;
+            const agg = byFile.get(file) ?? { project, sessions: 0, reads: 0, tokens: 0, usd: 0, priced: false };
+            agg.sessions++;
+            agg.reads += f.reads;
+            agg.tokens += f.tokens;
+            if (price) {
+                agg.usd += (f.tokens * 1.25 * price.inputPerM) / 1e6;
+                agg.priced = true;
+            }
+            byFile.set(file, agg);
+        }
+    }
+    const files = [...byFile.entries()]
+        .filter(([, a]) => a.sessions >= minSessions)
+        .map(([path, a]) => {
+        const ps = projectSessions.get(a.project) ?? a.sessions;
+        return {
+            path,
+            project: a.project,
+            sessions: a.sessions,
+            projectSessions: ps,
+            reads: a.reads,
+            tokens: a.tokens,
+            usd: a.priced ? a.usd : undefined,
+            // In most of the project's sessions: a summary in CLAUDE.md is read anyway, so it replaces the reads.
+            advice: a.sessions / ps >= 0.5 ? "summarize" : "pack",
+        };
+    })
+        .sort((a, b) => b.tokens - a.tokens);
+    return { days, sessions: list.length, reads, readTokens, files };
+}
+export function renderReads(r, limit = 15, home = process.env.HOME ?? "") {
+    const short = (p) => (home && p.startsWith(home) ? "~" + p.slice(home.length) : p);
+    const out = ["FILES READ INTO SESSION AFTER SESSION", "═".repeat(56)];
+    out.push(`Claude Code, last ${r.days} days: ${r.reads.toLocaleString("en-US")} file reads across ${r.sessions} sessions, ~${formatTokens(r.readTokens)} tokens.`);
+    if (r.files.length === 0) {
+        out.push("No file was read in 3 or more sessions. Nothing to consolidate.");
+        return out.join("\n");
+    }
+    const repeated = r.files.reduce((s, f) => s + f.tokens, 0);
+    out.push(`${r.files.length} files were read in 3+ sessions: ~${formatTokens(repeated)} tokens of reads (${Math.round((repeated / Math.max(1, r.readTokens)) * 100)}% of all read tokens).`, "");
+    for (const f of r.files.slice(0, limit)) {
+        const usd = f.usd !== undefined ? `  ≥${formatUsd(f.usd)}` : "";
+        out.push(`  ${String(f.sessions).padStart(3)}/${f.projectSessions} sessions  ${String(f.reads).padStart(4)} reads  ~${formatTokens(f.tokens).padStart(6)}${usd.padEnd(10)}  ${short(f.path)}`);
+    }
+    if (r.files.length > limit)
+        out.push(`  … ${r.files.length - limit} more (--json for all)`);
+    const summarize = r.files.filter((f) => f.advice === "summarize").slice(0, 5);
+    out.push("");
+    if (summarize.length) {
+        out.push(`Read in most of their project's sessions: ${summarize.map((f) => short(f.path)).join(", ")}.`, "   → A few lines in that project's CLAUDE.md saying what sessions need from each file replace most of these reads (CLAUDE.md is read on every request, so keep it to what is needed each time).");
+    }
+    out.push("   → For the rest, read the part a task needs: `pack_context` (MCP) or `context-doctor pack <file> -q \"…\"` returns the relevant chunks with line ranges.");
+    out.push("   (≥ = floor of the cost: each read written to the prompt cache once; every later request of that session re-reads it too.)");
+    return out.join("\n");
+}

package/dist/tasks.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `context-doctor tasks`: what a unit of finished work costs, per project.
+ *
+ * Tokens and dollars per session say little on their own; a session that
+ * shipped five commits and one that shipped none can cost the same. This
+ * prices each recent Claude Code session from the usage its transcript
+ * records (input, cache writes at 1.25x, cache reads at 0.1x, output), counts
+ * the commits the session itself made (successful `git commit` calls in its
+ * shell tool, in whichever repository), and reports per project: sessions,
+ * cost, commits, cost per commit, and how much went to sessions that
+ * committed nothing.
+ *
+ * Counting from the transcript attributes each commit to exactly one session
+ * and finds commits in nested repositories; a time window over `git log`
+ * did neither (a parent folder's repo showed none, a busy repo's unrelated
+ * history showed hundreds). Commits made by hand are not counted, nor is
+ * subagent traffic.
+ */
+export interface SessionCost {
+    path: string;
+    cwd?: string;
+    model?: string;
+    start: number;
+    end: number;
+    usd: number;
+    requests: number;
+    /** Successful `git commit` calls the session made. */
+    commits: number;
+}
+export interface ProjectTasks {
+    project: string;
+    sessions: number;
+    usd: number;
+    commits: number;
+    /** Sessions in which the project's repository got no commit, and what they cost. */
+    idleSessions: number;
+    idleUsd: number;
+    usdPerCommit?: number;
+}
+export interface TasksReport {
+    days: number;
+    projects: ProjectTasks[];
+    usd: number;
+    commits: number;
+}
+/** One session's bill, priced as the prompt cache bills it, from the usage the transcript records. */
+export declare function sessionCost(path: string): SessionCost | undefined;
+/** `git commit` invocations in a shell command (not --amend, --dry-run or commit-tree). */
+export declare function commitCount(cmd: string): number;
+export declare function costPerTask(days?: number, paths?: string[]): TasksReport;
+export declare function renderTasks(r: TasksReport, limit?: number): string;

package/dist/tasks.js

@@ -0,0 +1,140 @@
+/**
+ * `context-doctor tasks`: what a unit of finished work costs, per project.
+ *
+ * Tokens and dollars per session say little on their own; a session that
+ * shipped five commits and one that shipped none can cost the same. This
+ * prices each recent Claude Code session from the usage its transcript
+ * records (input, cache writes at 1.25x, cache reads at 0.1x, output), counts
+ * the commits the session itself made (successful `git commit` calls in its
+ * shell tool, in whichever repository), and reports per project: sessions,
+ * cost, commits, cost per commit, and how much went to sessions that
+ * committed nothing.
+ *
+ * Counting from the transcript attributes each commit to exactly one session
+ * and finds commits in nested repositories; a time window over `git log`
+ * did neither (a parent folder's repo showed none, a busy repo's unrelated
+ * history showed hundreds). Commits made by hand are not counted, nor is
+ * subagent traffic.
+ */
+import { basename } from "node:path";
+import { forEachLine, listSessions } from "./session.js";
+import { formatUsd, pricingFor } from "./pricing.js";
+/** One session's bill, priced as the prompt cache bills it, from the usage the transcript records. */
+export function sessionCost(path) {
+    let cwd, model, lastId;
+    let start = Infinity, end = 0, usd = 0, requests = 0, commits = 0;
+    const commitCalls = new Map();
+    forEachLine(path, (line) => {
+        if (!line.includes('"usage"') && !line.includes('"tool_result"') && cwd !== undefined)
+            return;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!e || e.isSidechain)
+            return;
+        if (!cwd && typeof e.cwd === "string")
+            cwd = e.cwd;
+        const content = Array.isArray(e.message?.content) ? e.message.content : [];
+        if (e.type === "assistant") {
+            for (const b of content) {
+                const cmd = b?.type === "tool_use" && (b.name === "Bash" || b.name === "shell") ? String(b.input?.command ?? "") : "";
+                const n = commitCount(cmd);
+                if (n)
+                    commitCalls.set(b.id, n);
+            }
+        }
+        else if (e.type === "user") {
+            for (const b of content) {
+                if (b?.type !== "tool_result" || !commitCalls.has(b.tool_use_id))
+                    continue;
+                if (!b.is_error)
+                    commits += commitCalls.get(b.tool_use_id);
+                commitCalls.delete(b.tool_use_id);
+            }
+            return;
+        }
+        if (e.type !== "assistant" || !e.message?.usage || e.message.id === lastId)
+            return;
+        lastId = e.message.id;
+        const at = Date.parse(e.timestamp);
+        if (Number.isFinite(at)) {
+            start = Math.min(start, at);
+            end = Math.max(end, at);
+        }
+        if (typeof e.message.model === "string")
+            model = e.message.model;
+        const price = pricingFor(e.message.model ?? model);
+        if (!price)
+            return;
+        const u = e.message.usage;
+        const n = (k) => (typeof u[k] === "number" && u[k] > 0 ? u[k] : 0);
+        usd += (n("input_tokens") * price.inputPerM + n("cache_creation_input_tokens") * price.inputPerM * 1.25 +
+            n("cache_read_input_tokens") * price.cacheReadPerM + n("output_tokens") * price.outputPerM) / 1e6;
+        requests++;
+    });
+    if (!requests || !Number.isFinite(start))
+        return undefined;
+    return { path, cwd, model, start, end, usd, requests, commits };
+}
+/** `git commit` invocations in a shell command (not --amend, --dry-run or commit-tree). */
+export function commitCount(cmd) {
+    let n = 0;
+    for (const part of cmd.split(/&&|\|\||;|\n/)) {
+        if (/^\s*git(\s+-[cC]\s+\S+)*\s+commit(\s|$)/.test(part) && !/--amend|--dry-run/.test(part))
+            n++;
+    }
+    return n;
+}
+export function costPerTask(days = 30, paths) {
+    const since = Date.now() - days * 86_400_000;
+    const list = paths ?? listSessions(10_000).filter((s) => s.path.includes(".claude") && s.modifiedAt.getTime() >= since).map((s) => s.path);
+    const byProject = new Map();
+    for (const p of list) {
+        const s = sessionCost(p);
+        if (!s || s.end < since)
+            continue;
+        const project = s.cwd ?? "?";
+        const agg = byProject.get(project) ?? { sessions: 0, usd: 0, commits: 0, idle: 0, idleUsd: 0 };
+        agg.sessions++;
+        agg.usd += s.usd;
+        agg.commits += s.commits;
+        if (s.commits === 0) {
+            agg.idle++;
+            agg.idleUsd += s.usd;
+        }
+        byProject.set(project, agg);
+    }
+    const projects = [...byProject.entries()]
+        .map(([project, a]) => ({
+        project,
+        sessions: a.sessions,
+        usd: a.usd,
+        commits: a.commits,
+        idleSessions: a.idle,
+        idleUsd: a.idleUsd,
+        usdPerCommit: a.commits ? a.usd / a.commits : undefined,
+    }))
+        .sort((a, b) => b.usd - a.usd);
+    return { days, projects, usd: projects.reduce((s, p) => s + p.usd, 0), commits: projects.reduce((s, p) => s + p.commits, 0) };
+}
+export function renderTasks(r, limit = 12) {
+    const out = ["COST PER TASK (the sessions' own commits as the unit of finished work)", "═".repeat(56)];
+    if (r.projects.length === 0)
+        return [...out, `No Claude Code sessions in the last ${r.days} days.`].join("\n");
+    out.push(`Last ${r.days} days at API list prices: ${formatUsd(r.usd)} across ${r.projects.reduce((s, p) => s + p.sessions, 0)} sessions, ${r.commits} commits.`, "");
+    out.push("  project                      sessions     cost  commits  per commit   no-commit sessions");
+    for (const p of r.projects.slice(0, limit)) {
+        const name = (p.project === "?" ? "?" : basename(p.project)).slice(0, 26).padEnd(26);
+        const per = p.usdPerCommit !== undefined ? formatUsd(p.usdPerCommit) : "—";
+        const idle = `${p.idleSessions} (${formatUsd(p.idleUsd)})`;
+        out.push(`  ${name} ${String(p.sessions).padStart(8)} ${formatUsd(p.usd).padStart(8)} ${String(p.commits).padStart(8)} ${per.padStart(11)}   ${idle}`);
+    }
+    if (r.projects.length > limit)
+        out.push(`  … ${r.projects.length - limit} more (--json for all)`);
+    out.push("", "Commits are the sessions' own successful `git commit` calls, in any repository; commits made by hand are not counted.", "Sessions with no commit are not waste by definition (research, reviews, deploys); a large share there is worth a look.");
+    return out.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-doctor",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Cut your Claude Code bill, measured on your own sessions: `npx context-doctor savings` shows what each lever saves, then the hook, autopilot and an earlier auto-compact window do it. Also Cursor, Codex, Claude Desktop and any Anthropic or OpenAI API app. MCP server and Claude Code plugin.",
   "keywords": [
     "agent",