context-doctor 0.31.0 → 0.32.0

package/dist/ci.js

@@ -10,7 +10,7 @@
  * Base contents come from `git show <base>:<path>`; nothing is checked out.
  */
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { join, posix } from "node:path";
 import { estimateTokens, formatTokens } from "./tokens.js";
 import { formatUsd, pricingFor } from "./pricing.js";
@@ -76,13 +76,33 @@ function measure(paths, read) {
         visit(p, false, 0);
     return out;
 }
+/** `-z` output: without it git quotes non-ASCII paths ("caf\303\251/CLAUDE.md") and they match nothing. */
+const paths0 = (out) => (out ?? "").split("\0").filter(Boolean);
+/** A file on disk, not a directory: `@src/components` names a folder, which Claude Code does not load. */
+function isFile(p) {
+    try {
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 export function ciReport(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const root = git(["rev-parse", "--show-toplevel"], cwd)?.trim() ?? cwd;
-    const headList = (git(["ls-files", "--cached", "--others", "--exclude-standard"], root) ?? "").split("\n").filter(Boolean);
-    const baseList = opts.base ? (git(["ls-tree", "-r", "--name-only", opts.base], root) ?? "").split("\n").filter(Boolean) : [];
-    const head = measure(headList.filter((p) => agentFor(p)), (p) => (existsSync(join(root, p)) ? readFileSync(join(root, p), "utf8") : undefined));
-    const base = opts.base ? measure(baseList.filter((p) => agentFor(p)), (p) => git(["show", `${opts.base}:${p}`], root)) : new Map();
+    // A base git cannot resolve (a typo, or a shallow clone that never fetched
+    // it) would read as an empty tree: every file "new", and a failure that
+    // blames the PR for the whole memory set. Stop and say so instead.
+    if (opts.base && git(["rev-parse", "--verify", "--quiet", `${opts.base}^{commit}`], root) === undefined) {
+        throw new Error(`--base ${opts.base} is not a commit in ${root}: check the name, or fetch it first (a shallow clone: git fetch --depth=1 origin ${opts.base})`);
+    }
+    const headList = paths0(git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root));
+    const baseList = opts.base ? paths0(git(["ls-tree", "-r", "-z", "--name-only", opts.base], root)) : [];
+    // ls-tree -r lists blobs only, so a path outside it (a folder, a missing file) has no base content;
+    // `git show base:folder` would print the folder's listing and count it as an imported file.
+    const baseFiles = new Set(baseList);
+    const head = measure(headList.filter((p) => agentFor(p)), (p) => (isFile(join(root, p)) ? readFileSync(join(root, p), "utf8") : undefined));
+    const base = opts.base ? measure(baseList.filter((p) => agentFor(p)), (p) => (baseFiles.has(p) ? git(["show", `${opts.base}:${p}`], root) : undefined)) : new Map();
     const files = [...new Set([...head.keys(), ...base.keys()])].sort().map((p) => ({
         path: p,
         agent: agentFor(p) ?? "Claude Code",

package/dist/cli.js

@@ -461,7 +461,9 @@ async function main() {
         const opts = { task: args.task, check: args.check, existing: args.existing, model: args.model, budgetUsd: args.budgetUsd, dryRun: args.dryRun, allowDirty: args.allowDirty };
         const result = runExperiment(opts);
         console.log(args.json ? JSON.stringify(result, null, 2) : renderExperiment(result, opts));
-        if (result.refused)
+        // No arm completed (claude missing, or every run errored): nothing was
+        // compared, and a script must not read exit 0 as a result.
+        if (result.refused || (result.arms.length > 0 && result.arms.every((a) => a.error)))
             process.exitCode = 1;
         return;
     }
@@ -493,7 +495,9 @@ async function main() {
     if (args.command === "cursor") {
         let chats;
         try {
-            chats = listCursorChats();
+            // An id is looked up among ALL chats: the default list keeps the 20
+            // largest, so a smaller chat's id used to fall through to the biggest one.
+            chats = listCursorChats(args.file && !args.list ? Infinity : undefined);
         }
         catch (e) {
             console.error(`Could not read Cursor history: ${e.message}`);
@@ -509,7 +513,12 @@ async function main() {
             }
             return;
         }
-        const chat = args.file ? chats.find((c) => c.composerId === args.file) ?? chats[0] : chats[0];
+        // A named chat that does not exist is an error, never a silent profile of another one.
+        const chat = args.file ? chats.find((c) => c.composerId === args.file) : chats[0];
+        if (!chat) {
+            console.error(`No Cursor chat with id "${args.file}" (context-doctor cursor --list shows the ids).`);
+            process.exit(1);
+        }
         const parsed = parseCursorChat(chat);
         const profile = profileConversation(parseConversation(parsed.conversationJson), args.model ?? parsed.model);
         if (args.json) {
@@ -557,9 +566,16 @@ async function main() {
         const profile = profileConversation(parseConversation(parsed.conversationJson), args.model ?? parsed.model);
         if (args.json) {
             console.log(JSON.stringify({ session: { path: parsed.path, title: parsed.title, toolTimings: parsed.toolTimings ?? [], subagents: subagentReport(path) }, profile }, null, 2));
+            // --json is what CI pipes, so the gate must hold here too (as it does for
+            // analyze); it used to run only after the text report and never failed.
+            applyBudgetGate(checkBudget(loadConfig(process.cwd(), (m) => console.error(`context-doctor: ${m}`)).config.budget, profile).overBudget, args.failOverBudget);
         }
         else {
-            console.log(`Session: ${parsed.title ?? "(untitled)"}\nFile:    ${parsed.path}`);
+            // Under --redact the title (the user's first prompt) and the path (which
+            // names the project) are content too.
+            console.log(args.redact
+                ? "Session: [redacted]\nFile:    [redacted]"
+                : `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.`);
             }
@@ -583,7 +599,7 @@ async function main() {
                 console.log("");
                 console.log(timing);
             }
-            const subs = renderSubagents(subagentReport(path), cacheUsage?.paidUsd);
+            const subs = renderSubagents(subagentReport(path), cacheUsage?.paidUsd, 5, { redact: args.redact });
             if (subs) {
                 console.log("");
                 console.log(subs);
@@ -698,7 +714,7 @@ async function main() {
         return;
     }
     if (args.command === "uninstall") {
-        runUninstall();
+        await runUninstall();
         return;
     }
     if (args.command === "proxy") {
@@ -774,7 +790,15 @@ async function main() {
         return;
     }
     if (args.command === "ci") {
-        const report = ciReport({ base: args.base, maxTokens: args.maxTokens, maxIncrease: args.maxIncrease });
+        let report;
+        try {
+            report = ciReport({ base: args.base, maxTokens: args.maxTokens, maxIncrease: args.maxIncrease });
+        }
+        catch (e) {
+            // A base git cannot resolve (a typo, a shallow clone) is a usage error, not a crash.
+            console.error(`context-doctor: ${e.message}`);
+            process.exit(1);
+        }
         console.log(args.json ? JSON.stringify(report, null, 2) : args.markdown ? renderCiMarkdown(report, { model: args.model, requestsPerDay: args.requestsPerDay }) : renderCiText(report));
         if (report.breaches.length)
             process.exitCode = 1;
@@ -847,26 +871,37 @@ async function main() {
     if (args.command === "analyze") {
         const loaded = loadConfig(process.cwd(), (m) => console.error(`context-doctor: ${m}`));
         const profile = profileConversation(parseConversation(input), args.model ?? loaded.config.model);
-        console.log(args.json ? JSON.stringify(profile, null, 2) : renderProfile(profile, { redact: args.redact }));
-        if (!args.json)
-            applyBudgetGate(printBudgetStatus(profile, loaded), args.failOverBudget);
-        else
+        // The exact count is awaited before anything prints: with --json it goes
+        // inside the one JSON object. Printed after it, as it once was, the extra
+        // lines made stdout invalid JSON for every script that parsed it.
+        const exact = args.exact ? await exactTokenCount(input, args.model) : undefined;
+        let drift;
+        let remembered = false;
+        if (exact?.tokens !== undefined) {
+            drift = profile.totalTokens > 0 ? Math.round(((exact.tokens - profile.totalTokens) / exact.tokens) * 100) : 0;
+            // Remember the comparison so the next estimate for this model family
+            // starts from the user's own ground truth instead of a constant.
+            const raw = profile.calibration ? profile.totalTokens / profile.calibration.factor : profile.totalTokens;
+            remembered = recordCalibration(args.model ?? profile.model, exact.tokens, raw);
+        }
+        if (args.json) {
+            const out = exact ? { ...profile, exact: { ...exact, driftPct: drift, calibrationRecorded: remembered } } : profile;
+            console.log(JSON.stringify(out, null, 2));
             applyBudgetGate(checkBudget(loaded.config.budget, profile).overBudget, args.failOverBudget);
-        if (args.exact) {
-            void exactTokenCount(input, args.model).then((exact) => {
-                if (exact.tokens !== undefined) {
-                    const drift = profile.totalTokens > 0 ? Math.round(((exact.tokens - profile.totalTokens) / exact.tokens) * 100) : 0;
-                    console.log(`\nExact input tokens: ${exact.tokens} (${exact.source}) — heuristic was off by ${drift}%`);
-                    // Remember the comparison so the next estimate for this model family
-                    // starts from the user's own ground truth instead of a constant.
-                    const raw = profile.calibration ? profile.totalTokens / profile.calibration.factor : profile.totalTokens;
-                    recordCalibration(args.model ?? profile.model, exact.tokens, raw);
-                    console.log(`Remembered: future ${modelFamily(args.model ?? profile.model)} estimates on this machine are calibrated from this (CONTEXT_DOCTOR_NO_CALIBRATION=1 to disable).`);
-                }
-                else {
-                    console.log(`\nExact count unavailable: ${exact.note}`);
-                }
-            });
+            return;
+        }
+        console.log(renderProfile(profile, { redact: args.redact }));
+        applyBudgetGate(printBudgetStatus(profile, loaded), args.failOverBudget);
+        if (exact?.tokens !== undefined) {
+            console.log(`\nExact input tokens: ${exact.tokens} (${exact.source}) — heuristic was off by ${drift}%`);
+            // Only claim it when it happened: a sample outside 0.5-2x is rejected,
+            // and CONTEXT_DOCTOR_NO_CALIBRATION=1 stores nothing.
+            if (remembered) {
+                console.log(`Remembered: future ${modelFamily(args.model ?? profile.model)} estimates on this machine are calibrated from this (CONTEXT_DOCTOR_NO_CALIBRATION=1 to disable).`);
+            }
+        }
+        else if (exact) {
+            console.log(`\nExact count unavailable: ${exact.note}`);
         }
         return;
     }

package/dist/coldresume.d.ts

@@ -3,10 +3,11 @@
  *
  * Claude Code caches the conversation for an hour on a subscription (five
  * minutes on the API). Come back later and the next message re-sends the
- * whole context at the cache-WRITE rate (1.25x), and every message after it
- * re-reads it (0.1x each). On a 500k-token session that is the most expensive
- * moment of the day, and the one moment `/compact` is cheapest to accept:
- * the cache is being rebuilt anyway.
+ * whole context at the cache-WRITE rate (2x input for the 1-hour cache,
+ * 1.25x for 5 minutes), and every message after it re-reads it (the model's
+ * cache-read rate, 2.5-10% of input). On a 500k-token session that is the
+ * most expensive moment of the day, and the one moment `/compact` is
+ * cheapest to accept: the cache is being rebuilt anyway.
  *
  * Measured on the author's 133 days of Claude Code history: 401 returns to a
  * session over 150k tokens after more than 65 idle minutes (median context
@@ -14,7 +15,11 @@
  * request itself and only the messages up to the next such return, would have
  * saved $4,053 at list price, about $914 a month; it paid off in 296 of 401
  * cases, and the worst single loss was $2.30 (sessions left after a few more
- * messages). So this advises, with the numbers, and the user decides.
+ * messages). So this advises, with the numbers, and the user decides. (That
+ * replay priced reads at 0.1x and writes at 1.25x of the session's first
+ * model. At each model's own read rate, Opus 5.5 at 5% and Fable 5.1 at
+ * 2.5%, the re-reads compaction avoids cost far less: the author's last 7
+ * days went from $332 to $139.)
  *
  * It works where the proxy cannot: the desktop app's Code tab runs Claude Code
  * host-orchestrated and drops a settings-file ANTHROPIC_BASE_URL, but it runs
@@ -31,7 +36,7 @@ export interface ColdResume {
     model?: string;
     /** Timestamp of the last assistant reply: identifies this idle period. */
     lastReplyAt: number;
-    /** This message's cost to rebuild the cache, at list price. */
+    /** This message's cost to rebuild the cache, at list price and the session's write TTL mix. */
     resumeUsd?: number;
     /** Each later message's cost to re-read the context, at list price. */
     perMessageUsd?: number;
@@ -41,6 +46,17 @@ export interface ColdResume {
  * Reads only the transcript's tail. Undefined when not (or when unreadable).
  */
 export declare function detectColdResume(path: string, now?: number, idleMs?: number, minTokens?: number): ColdResume | undefined;
+/**
+ * What this session pays to write a token to the cache, relative to input:
+ * the 5-minute/1-hour mix of the main-thread writes in the transcript's
+ * tail (subagents write 5 minutes and are not this context). The tail, not
+ * the whole file, because it is the TTL the harness writes at now: on the
+ * author's machine Claude Code 2.1.295 (desktop app) moved main-thread
+ * writes from 1 hour to 5 minutes, and 7 of the 12 largest recent sessions
+ * switched mid-file. 1.25x when the tail records no split or no writes.
+ * Reads only the tail, so the every-prompt hook can afford it.
+ */
+export declare function sessionWriteMultiplier(path: string): number;
 /**
  * The one line shown to the USER in the app (hook `systemMessage`). In the
  * first week the offer lived only inside the model's reply and was acted on
@@ -61,8 +77,17 @@ export interface ColdResumeEvent {
  * Replay a transcript's billed usage and price what compacting at each cold
  * resume would have saved. Each resume only counts the messages up to the
  * next one (no double counting), and the compaction request is a cost.
+ *
+ * Each request at its own model's prices: a session that moved from a $4 to
+ * a $10 model was priced at the first throughout, and one that opened with
+ * a "<synthetic>" row not at all. A re-write that never happened (a cold
+ * read of what compaction would have removed, the fresh context after it)
+ * at the session's own 5-minute/1-hour write mix, not 1.25x. `runRows` is
+ * shared by every transcript of one report (see replyCounter): a forked
+ * session's copy of its parent's history shapes the timeline, but a resume
+ * in it was counted under the transcript that met it first.
  */
-export declare function coldResumeEvents(path: string, idleMs?: number, minTokens?: number): ColdResumeEvent[];
+export declare function coldResumeEvents(path: string, idleMs?: number, minTokens?: number, runRows?: Set<string>): ColdResumeEvent[];
 /**
  * How often the cold-resume offer was acted on: offers (ledger events) whose
  * session has a compaction within an hour after. `sessionPaths` maps the

package/dist/coldresume.js

@@ -3,10 +3,11 @@
  *
  * Claude Code caches the conversation for an hour on a subscription (five
  * minutes on the API). Come back later and the next message re-sends the
- * whole context at the cache-WRITE rate (1.25x), and every message after it
- * re-reads it (0.1x each). On a 500k-token session that is the most expensive
- * moment of the day, and the one moment `/compact` is cheapest to accept:
- * the cache is being rebuilt anyway.
+ * whole context at the cache-WRITE rate (2x input for the 1-hour cache,
+ * 1.25x for 5 minutes), and every message after it re-reads it (the model's
+ * cache-read rate, 2.5-10% of input). On a 500k-token session that is the
+ * most expensive moment of the day, and the one moment `/compact` is
+ * cheapest to accept: the cache is being rebuilt anyway.
  *
  * Measured on the author's 133 days of Claude Code history: 401 returns to a
  * session over 150k tokens after more than 65 idle minutes (median context
@@ -14,25 +15,54 @@
  * request itself and only the messages up to the next such return, would have
  * saved $4,053 at list price, about $914 a month; it paid off in 296 of 401
  * cases, and the worst single loss was $2.30 (sessions left after a few more
- * messages). So this advises, with the numbers, and the user decides.
+ * messages). So this advises, with the numbers, and the user decides. (That
+ * replay priced reads at 0.1x and writes at 1.25x of the session's first
+ * model. At each model's own read rate, Opus 5.5 at 5% and Fable 5.1 at
+ * 2.5%, the re-reads compaction avoids cost far less: the author's last 7
+ * days went from $332 to $139.)
  *
  * It works where the proxy cannot: the desktop app's Code tab runs Claude Code
  * host-orchestrated and drops a settings-file ANTHROPIC_BASE_URL, but it runs
  * the every-prompt hook, which is where this is called from.
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
-import { forEachLine } from "./session.js";
-import { pricingFor, formatUsd } from "./pricing.js";
-import { formatTokens } from "./tokens.js";
+import { forEachLine, replyCounter } from "./session.js";
+import { cacheWriteSplit, pricingFor, formatUsd, writeMultiplier } from "./pricing.js";
+import { formatTokens, realModel } from "./tokens.js";
 /** Just past Claude Code's one-hour cache, as Claude Code's own idle clearing uses. */
 export const COLD_IDLE_MS = 65 * 60_000;
+/** Margin past a cache's lifetime before a return counts as cold. */
+const COLD_MARGIN_MS = 5 * 60_000;
+const HOUR_MS = 3_600_000;
+const FIVE_MIN_MS = 5 * 60_000;
+/**
+ * How long the cache entry a reply left behind lives: one hour when the reply
+ * wrote the 1-hour cache, five minutes when it wrote only the 5-minute one,
+ * and otherwise whatever the last write before it used (a read refreshes an
+ * entry at its own lifetime). Claude Code's main thread wrote the 1-hour cache
+ * until 2.1.295, which often writes the 5-minute one (in the author's last 3
+ * days, 1,307 main-thread replies wrote only 5-minute entries): a gate fixed
+ * at 65 minutes missed every return between 10 and 65 minutes to those
+ * sessions, cold as they were. Undefined when nothing says.
+ */
+function writtenTtlMs(u) {
+    // Only an explicit split says: cacheWriteSplit books unsplit writes as
+    // 5-minute for pricing, which would make every old transcript look short-lived.
+    const split = u?.cache_creation;
+    if (!split)
+        return undefined;
+    if ((split.ephemeral_1h_input_tokens ?? 0) > 0)
+        return HOUR_MS;
+    if ((split.ephemeral_5m_input_tokens ?? 0) > 0)
+        return FIVE_MIN_MS;
+    return undefined;
+}
 /** Below this, a rebuilt cache is cheap and compaction is not worth the interruption. */
 export const COLD_MIN_TOKENS = 150_000;
 /** What a compacted session restarts from: system prompt and tools plus the summary. */
 const AFTER_COMPACT_TOKENS = 45_000;
-/** Output tokens a compaction summary costs, and output's price relative to input. */
+/** Output tokens a compaction summary costs, at the model's output price. */
 const SUMMARY_OUTPUT_TOKENS = 8_000;
-const OUTPUT_PRICE_RATIO = 5;
 function tailLines(path, bytes = 256 * 1024) {
     const size = statSync(path).size;
     const n = Math.min(size, bytes);
@@ -50,9 +80,11 @@ function tailLines(path, bytes = 256 * 1024) {
  * Is the prompt being submitted now a return to a large, cache-cold session?
  * Reads only the transcript's tail. Undefined when not (or when unreadable).
  */
-export function detectColdResume(path, now = Date.now(), idleMs = COLD_IDLE_MS, minTokens = COLD_MIN_TOKENS) {
+export function detectColdResume(path, now = Date.now(), idleMs, minTokens = COLD_MIN_TOKENS) {
     try {
-        for (const line of tailLines(path)) {
+        const lines = tailLines(path);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
             let e;
             try {
                 e = JSON.parse(line);
@@ -78,17 +110,34 @@ export function detectColdResume(path, now = Date.now(), idleMs = COLD_IDLE_MS,
             if (!Number.isFinite(lastReplyAt))
                 return undefined;
             const idle = now - lastReplyAt;
-            if (idle < idleMs || tokens < minTokens)
+            // The cache lives as long as the last write said (see writtenTtlMs);
+            // with nothing recorded, the hour Claude Code used to write.
+            let ttl = writtenTtlMs(u);
+            for (let j = i + 1; ttl === undefined && j < lines.length; j++) {
+                try {
+                    const earlier = JSON.parse(lines[j]);
+                    if (earlier?.type === "assistant" && !earlier.isSidechain)
+                        ttl = writtenTtlMs(earlier.message?.usage);
+                }
+                catch { /* partial line at the tail's start */ }
+            }
+            const gate = idleMs ?? (ttl ?? HOUR_MS) + COLD_MARGIN_MS;
+            if (idle < gate || tokens < minTokens)
                 return undefined;
-            const model = e.message?.model;
+            const model = realModel(e.message?.model);
             const p = pricingFor(model);
+            // The rebuild is written at the TTL this session writes at: Claude
+            // Code's main thread has mostly written the 1-hour cache (2x input,
+            // 97% of the author's main-thread writes), which a flat 1.25x
+            // underpriced by 37%. Re-reads at the model's own read rate (Opus 5.5
+            // reads at 5% of input, not 10%).
             return {
                 idleMs: idle,
                 tokens,
                 model,
                 lastReplyAt,
-                resumeUsd: p ? (tokens * 1.25 * p.inputPerM) / 1e6 : undefined,
-                perMessageUsd: p ? (tokens * 0.1 * p.inputPerM) / 1e6 : undefined,
+                resumeUsd: p ? (tokens * sessionWriteMultiplier(path) * p.inputPerM) / 1e6 : undefined,
+                perMessageUsd: p ? (tokens * p.cacheReadPerM) / 1e6 : undefined,
             };
         }
     }
@@ -97,6 +146,49 @@ export function detectColdResume(path, now = Date.now(), idleMs = COLD_IDLE_MS,
     }
     return undefined;
 }
+/**
+ * What this session pays to write a token to the cache, relative to input:
+ * the 5-minute/1-hour mix of the main-thread writes in the transcript's
+ * tail (subagents write 5 minutes and are not this context). The tail, not
+ * the whole file, because it is the TTL the harness writes at now: on the
+ * author's machine Claude Code 2.1.295 (desktop app) moved main-thread
+ * writes from 1 hour to 5 minutes, and 7 of the 12 largest recent sessions
+ * switched mid-file. 1.25x when the tail records no split or no writes.
+ * Reads only the tail, so the every-prompt hook can afford it.
+ */
+export function sessionWriteMultiplier(path) {
+    let writes5m = 0, writes1h = 0;
+    try {
+        const ids = new Set();
+        for (const line of tailLines(path)) {
+            if (!line.includes('"cache_creation_input_tokens"'))
+                continue;
+            let e;
+            try {
+                e = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (e?.type !== "assistant" || e.isSidechain || !e.message?.usage)
+                continue;
+            // One reply is several rows carrying the same usage.
+            const id = e.message.id;
+            if (typeof id === "string") {
+                if (ids.has(id))
+                    continue;
+                ids.add(id);
+            }
+            const w = cacheWriteSplit(e.message.usage);
+            writes5m += w.fiveMinute;
+            writes1h += w.oneHour;
+        }
+    }
+    catch {
+        /* unreadable transcript: the API's default TTL */
+    }
+    return writeMultiplier(writes5m, writes1h);
+}
 function duration(ms) {
     const m = Math.round(ms / 60_000);
     if (m < 90)
@@ -130,10 +222,21 @@ export function renderColdResume(c) {
  * Replay a transcript's billed usage and price what compacting at each cold
  * resume would have saved. Each resume only counts the messages up to the
  * next one (no double counting), and the compaction request is a cost.
+ *
+ * Each request at its own model's prices: a session that moved from a $4 to
+ * a $10 model was priced at the first throughout, and one that opened with
+ * a "<synthetic>" row not at all. A re-write that never happened (a cold
+ * read of what compaction would have removed, the fresh context after it)
+ * at the session's own 5-minute/1-hour write mix, not 1.25x. `runRows` is
+ * shared by every transcript of one report (see replyCounter): a forked
+ * session's copy of its parent's history shapes the timeline, but a resume
+ * in it was counted under the transcript that met it first.
  */
-export function coldResumeEvents(path, idleMs = COLD_IDLE_MS, minTokens = COLD_MIN_TOKENS) {
+export function coldResumeEvents(path, idleMs, minTokens = COLD_MIN_TOKENS, runRows) {
+    let ttl = HOUR_MS;
     const reqs = [];
-    let lastId, model;
+    let model, writes5m = 0, writes1h = 0;
+    const sighting = replyCounter(runRows);
     forEachLine(path, (line) => {
         let e;
         try {
@@ -148,20 +251,24 @@ export function coldResumeEvents(path, idleMs = COLD_IDLE_MS, minTokens = COLD_M
             reqs.push("compact");
             return;
         }
-        if (e.type !== "assistant" || !e.message || e.message.id === lastId)
+        if (e.type !== "assistant" || !e.message)
+            return;
+        const seen = sighting(e);
+        if (seen === "repeat")
             return;
-        lastId = e.message.id;
         const u = e.message.usage ?? {};
         const total = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
         const at = Date.parse(e.timestamp);
-        if (total > 0 && Number.isFinite(at)) {
-            reqs.push({ at, total });
-            model ??= e.message.model;
-        }
+        if (!(total > 0) || !Number.isFinite(at))
+            return;
+        model = realModel(e.message.model) ?? model;
+        const w = cacheWriteSplit(u);
+        writes5m += w.fiveMinute;
+        writes1h += w.oneHour;
+        ttl = writtenTtlMs(u) ?? ttl;
+        reqs.push({ at, total, price: pricingFor(model), copy: seen === "copy", ttl });
     });
-    const perM = pricingFor(model)?.inputPerM;
-    if (!perM)
-        return [];
+    const mix = writeMultiplier(writes5m, writes1h);
     const real = reqs.filter((r) => r !== "compact");
     if (real.length < 2)
         return [];
@@ -170,21 +277,28 @@ export function coldResumeEvents(path, idleMs = COLD_IDLE_MS, minTokens = COLD_M
         const a = reqs[i - 1], b = reqs[i];
         if (a === "compact" || b === "compact")
             continue;
-        if (b.at - a.at <= idleMs || b.total < minTokens)
+        // Cold once the gap outlives the cache the previous request left behind.
+        const gate = (r) => idleMs ?? r.ttl + COLD_MARGIN_MS;
+        if (b.at - a.at <= gate(a) || b.total < minTokens)
+            continue;
+        if (b.copy || !b.price)
             continue;
         const removed = Math.max(0, b.total - AFTER_COMPACT_TOKENS);
-        let saved = 0, n = 0, prev = b.at;
+        let saved = 0, n = 0, prev = b;
         for (const c of reqs.slice(i + 1)) {
             if (c === "compact")
                 break;
-            if (c.at - prev > idleMs && c.total >= minTokens)
+            if (c.at - prev.at > gate(prev) && c.total >= minTokens)
                 break;
-            saved += (c.at - prev > 3_600_000 ? 1.25 : 0.1) * removed;
-            prev = c.at;
+            const p = c.price ?? b.price;
+            saved += removed * (c.at - prev.at > prev.ttl ? mix * p.inputPerM : p.cacheReadPerM);
+            prev = c;
             n++;
         }
-        const cost = 0.1 * b.total + OUTPUT_PRICE_RATIO * SUMMARY_OUTPUT_TOKENS + 1.25 * AFTER_COMPACT_TOKENS;
-        events.push({ at: b.at, tokens: b.total, messagesAfter: n, netUsd: ((saved - cost) * perM) / 1e6 });
+        // The compaction re-reads the context just rebuilt and writes a summary;
+        // the next request writes the fresh context.
+        const cost = b.total * b.price.cacheReadPerM + SUMMARY_OUTPUT_TOKENS * b.price.outputPerM + mix * AFTER_COMPACT_TOKENS * b.price.inputPerM;
+        events.push({ at: b.at, tokens: b.total, messagesAfter: n, netUsd: (saved - cost) / 1e6 });
     }
     return events;
 }

package/dist/compactquality.js

@@ -15,7 +15,7 @@
  * Compactions shaped by context-doctor's PreCompact hook are reported apart,
  * so its effect can be seen as it accumulates.
  */
-import { forEachLine, listSessions } from "./session.js";
+import { forEachLine, listSessions, queuedUserPrompt } from "./session.js";
 import { readLedger } from "./ledger.js";
 import { estimateTokens, formatTokens } from "./tokens.js";
 const WINDOW = 15;
@@ -43,12 +43,26 @@ export function compactionQuality(days = 60, paths) {
     const shapedAt = readLedger().filter((e) => e.ev === "precompact").map((e) => e.ts);
     const q = { compactions: 0, extraRereadTokensPerCompaction: 0, sessions: 0, before: empty(), after: empty() };
     const shaped = { compactions: 0, before: empty(), after: empty() };
+    // A forked session copies its parent's compactions (same row uuid): one compaction, counted once.
+    const countedBoundaries = new Set();
     for (const path of files) {
         const reqs = [];
+        /** `at` is NaN when the row carries no timestamp. */
         const boundaries = [];
         let cur;
         // User messages between a compaction and the next request belong to the "after" side.
         let pendingUser = 0, pendingCorrections = 0;
+        const userMessage = (text) => {
+            const corr = CORRECTION.test(text.trim()) ? 1 : 0;
+            if (cur) {
+                cur.userMsgs++;
+                cur.corrections += corr;
+            }
+            else {
+                pendingUser++;
+                pendingCorrections += corr;
+            }
+        };
         const readIds = new Map();
         let lastId;
         forEachLine(path, (line) => {
@@ -63,10 +77,21 @@ export function compactionQuality(days = 60, paths) {
                 return;
             const at = Date.parse(e.timestamp);
             if (e.type === "system" && e.subtype === "compact_boundary") {
-                boundaries.push({ index: reqs.length, at: Number.isFinite(at) ? at : 0 });
+                const copy = typeof e.uuid === "string" && countedBoundaries.has(e.uuid);
+                if (typeof e.uuid === "string")
+                    countedBoundaries.add(e.uuid);
+                if (!copy)
+                    boundaries.push({ index: reqs.length, at });
                 cur = undefined;
                 return;
             }
+            // Typed while the agent worked: a user message recorded only as an
+            // attachment, and the likeliest moment for a "no, stop" to arrive.
+            const queued = queuedUserPrompt(e);
+            if (queued !== undefined) {
+                userMessage(typeof queued === "string" ? queued : queued.map((b) => (typeof b?.text === "string" ? b.text : "")).join(" "));
+                return;
+            }
             const c = e.message?.content;
             if (e.type === "assistant") {
                 if (e.message?.id !== lastId && e.message?.usage) {
@@ -87,15 +112,7 @@ export function compactionQuality(days = 60, paths) {
             }
             else if (e.type === "user") {
                 if (typeof c === "string" && !e.isMeta && !e.isCompactSummary) {
-                    const corr = CORRECTION.test(c.trim()) ? 1 : 0;
-                    if (cur) {
-                        cur.userMsgs++;
-                        cur.corrections += corr;
-                    }
-                    else {
-                        pendingUser++;
-                        pendingCorrections += corr;
-                    }
+                    userMessage(c);
                 }
                 else if (cur && Array.isArray(c)) {
                     for (const b of c) {
@@ -115,6 +132,10 @@ export function compactionQuality(days = 60, paths) {
         });
         let counted = false;
         for (const b of boundaries) {
+            // Each compaction by its own time: a session touched in the window
+            // brought in all its older compactions. Undated ones count with the file.
+            if (b.at < since)
+                continue;
             const before = reqs.slice(Math.max(0, b.index - WINDOW), b.index);
             const after = reqs.slice(b.index, b.index + WINDOW);
             if (before.length < 5 || after.length < 5)
@@ -167,7 +188,8 @@ export function renderCompactionQuality(q, days = 60) {
     const worse = a.error - b.error > 0.03 || a.correction - b.correction > 0.05;
     out.push("");
     if (forgets) {
-        out.push(`Compacting forgets files: each compaction is followed by ~${formatTokens(q.extraRereadTokensPerCompaction)} tokens of extra re-reads. compact-window charges that to every compaction it simulates.`);
+        // Rounded: an average below 1k otherwise printed as "~237.46428571428572".
+        out.push(`Compacting forgets files: each compaction is followed by ~${formatTokens(Math.round(q.extraRereadTokensPerCompaction))} tokens of extra re-reads. compact-window charges that to every compaction it simulates.`);
     }
     out.push(worse
         ? "Sessions also work worse after compacting (more tool errors or corrections): compact less often, and let the PreCompact hook tell each summary what to keep."