prehello 0.0.0-stage → 1.0.0

package/dist/agents.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_NAMES = exports.ALL_AGENTS = exports.AGENTS = void 0;
+exports.agentMeta = agentMeta;
+exports.AGENTS = [
+    {
+        id: "claude-code",
+        name: "Claude Code",
+        tokenFamily: "claude",
+        lookedFor: "~/.claude, ~/.claude.json, `claude` on PATH; CLAUDE.md, .claude/, .mcp.json in the project",
+        whereLooked: "CLAUDE.md (project, parent folders, ~/.claude), .claude/{rules,skills,commands}, plugins, .mcp.json, ~/.claude.json",
+        projectMarkers: ["CLAUDE.md", "CLAUDE.local.md", ".mcp.json", ".claude/"],
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        tokenFamily: "mixed",
+        lookedFor: "~/.cursor, Cursor.app, `cursor` on PATH; .cursor/, .cursorrules, AGENTS.md in the project",
+        whereLooked: ".cursor/rules (incl. nested), AGENTS.md, .cursorrules, skills folders, ~/.cursor/{skills,plugins,mcp.json}, .cursor/mcp.json",
+        hint: "Cursor's User Rules live inside the app, not on disk. Paste them into a file and run with --paste-user-rules <file> to count them.",
+        cardChips: ["unmeasured: User Rules"],
+        projectMarkers: [".cursorrules", "AGENTS.md", ".cursor/"],
+    },
+    {
+        id: "codex",
+        name: "Codex",
+        tokenFamily: "openai",
+        lookedFor: "~/.codex, `codex` on PATH; AGENTS.md, .codex/, .agents/skills in the project",
+        whereLooked: "AGENTS.md chain, ~/.codex/{AGENTS.md,config.toml}, .agents/skills, ~/.agents/skills, .codex/config.toml",
+        projectMarkers: ["AGENTS.md", ".codex/", ".agents/"],
+    },
+    {
+        id: "github-copilot",
+        name: "GitHub Copilot",
+        tokenFamily: "mixed",
+        lookedFor: "~/.copilot, `copilot` on PATH, the VS Code Copilot Chat extension; .github/copilot-instructions.md, .github/instructions/, .github/prompts/, .vscode/mcp.json in the project",
+        whereLooked: ".github/copilot-instructions.md, AGENTS.md/CLAUDE.md/GEMINI.md (repo root → cwd), .github/instructions/**, .github/prompts/**, ~/.copilot/{copilot-instructions.md,instructions,mcp-config.json}, .mcp.json, .github/mcp.json, .vscode/mcp.json, VS Code user mcp.json",
+        hint: "Organization instructions and VS Code settings-based instructions live on GitHub or in VS Code settings, not in the scanned files.",
+        projectMarkers: [".github/copilot-instructions.md", ".github/instructions/", ".vscode/mcp.json"],
+    },
+    {
+        id: "gemini-cli",
+        name: "Gemini CLI",
+        tokenFamily: "gemini",
+        lookedFor: "~/.gemini, `gemini` on PATH; GEMINI.md, .gemini/ in the project",
+        whereLooked: "~/.gemini/GEMINI.md, GEMINI.md (cwd → project root, and below cwd), context.fileName, ~/.gemini/extensions/*, ~/.gemini/settings.json, .gemini/settings.json, .gemini/skills, .agents/skills",
+        projectMarkers: ["GEMINI.md", ".gemini/"],
+    },
+];
+exports.ALL_AGENTS = exports.AGENTS.map((a) => a.id);
+exports.AGENT_NAMES = Object.fromEntries(exports.AGENTS.map((a) => [a.id, a.name]));
+function agentMeta(id) {
+    return exports.AGENTS.find((a) => a.id === id);
+}

package/dist/analyze/findings.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crossFindings = crossFindings;
+exports.rankFindings = rankFindings;
+const context_1 = require("../context");
+const model_1 = require("../model");
+const fmt_1 = require("../util/fmt");
+const MAX_DUP_DOCS = 300;
+const MAX_DUP_PAIRS = 20;
+/** Cross-document findings (F2 duplicates) and MCP lower-bound notes (F5). */
+function crossFindings(ctx, agents) {
+    // Bounded on purpose: comparing every pair is quadratic, and 200 copies of one rule file are 19,900 "duplicate" pairs.
+    // Compare the biggest MAX_DUP_DOCS files, list the MAX_DUP_PAIRS most similar pairs, and say how many were left out.
+    const all = [...ctx.docs.values()].filter((d) => d.tokens >= 200 && d.shingles.size > 0).sort((x, y) => y.tokens - x.tokens || (0, fmt_1.cmp)(x.path, y.path));
+    const docs = all.slice(0, MAX_DUP_DOCS);
+    if (all.length > docs.length)
+        ctx.warn(`duplicate check compared only the ${MAX_DUP_DOCS} largest of ${all.length} context files`);
+    const pairs = [];
+    for (let i = 0; i < docs.length; i++) {
+        for (let j = i + 1; j < docs.length; j++) {
+            const a = docs[i];
+            const b = docs[j];
+            const sim = (0, context_1.jaccard)(a.shingles, b.shingles);
+            if (sim < 0.6)
+                continue;
+            const common = [...a.agents].filter((x) => b.agents.has(x));
+            let savings;
+            if (common.length) {
+                const smaller = Math.min(a.tokens, b.tokens);
+                savings = Math.round(ctx.profile(common[0]).apply(smaller).est * sim);
+            }
+            pairs.push({ a, b, sim, common, savings });
+        }
+    }
+    pairs.sort((x, y) => y.sim - x.sim || (y.savings ?? 0) - (x.savings ?? 0) || (0, fmt_1.cmp)(x.a.path, y.a.path) || (0, fmt_1.cmp)(x.b.path, y.b.path));
+    for (const { a, b, sim, common, savings } of pairs.slice(0, MAX_DUP_PAIRS)) {
+        ctx.addFinding({
+            id: "F2",
+            severity: "warn",
+            agent: common[0] ?? "all",
+            message: `${ctx.display(a.path)} and ${ctx.display(b.path)} are ~${Math.round(sim * 100)}% duplicate text${common.length ? "" : " (loaded by different agents)"}`,
+            paths: [a.path, b.path],
+            savingsTokens: savings,
+            confidence: sim >= 0.9 ? "high" : "medium",
+            data: { similarityPct: Math.round(sim * 100) },
+            fix: common.length
+                ? "Keep one copy. Claude Code @imports do not reduce cost, so delete the duplicate rather than importing it."
+                : "Different agents read these files, so do not delete either. To stop them drifting apart, make one the source of truth (for example, a CLAUDE.md that contains just `@AGENTS.md`, or a symlink). This saves no tokens.",
+        });
+    }
+    if (pairs.length > MAX_DUP_PAIRS) {
+        ctx.addFinding({
+            id: "F2",
+            severity: "info",
+            agent: "all",
+            message: `${pairs.length - MAX_DUP_PAIRS} more near-duplicate pairs are not listed (the ${MAX_DUP_PAIRS} most similar are shown)`,
+            paths: [],
+            confidence: "high",
+            data: { omittedPairs: pairs.length - MAX_DUP_PAIRS },
+        });
+    }
+    for (const ag of agents) {
+        const n = ag.totals.always.unmeasuredItems;
+        const unm = ag.items.filter((i) => i.loadMode === "always" && i.tokens === null);
+        const what = unm.every((i) => i.kind === "mcp-server") ? "MCP servers" : unm.some((i) => i.kind === "mcp-server") ? "MCP servers and unreadable files" : "files that could not be read";
+        if (n > 0 && !ag.presentInRepoOnly) {
+            ctx.addFinding({
+                id: "F5",
+                severity: "info",
+                agent: ag.id,
+                message: `${model_1.AGENT_NAMES[ag.id]}: ${n} always-loaded item${n > 1 ? "s are" : " is"} unmeasured (${what}); the always-on total is a lower bound ("at least")`,
+                paths: [],
+                confidence: "needs-your-call",
+                fix: unm.some((i) => i.kind === "mcp-server") ? "If a server is unused, disable or remove it in the agent's own settings. prehello never edits MCP configs." : undefined,
+            });
+        }
+    }
+}
+function rankFindings(fs) {
+    const sev = { warn: 0, info: 1 };
+    return [...fs].sort((a, b) => (b.savingsTokens ?? 0) - (a.savingsTokens ?? 0) || sev[a.severity] - sev[b.severity] || (0, fmt_1.cmp)(a.id, b.id) || (0, fmt_1.cmp)(a.message, b.message));
+}

package/dist/analyze/grade.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUBRIC = void 0;
+exports.gradeAgent = gradeAgent;
+exports.RUBRIC = [
+    "Start at 100 points per agent. Rubric uses only documented guidelines; it is a heuristic, not an industry standard.",
+    "Always-on tokens as a share of the window (estimate): ≥20% −45 · ≥10% −30 · ≥5% −15 · ≥2% −5",
+    "Each always-on instruction file over its documented guideline (Claude Code 200 lines, Cursor rules 500 lines): −5, max −15",
+    "Each place content is silently truncated (Codex 32 KiB cap, MEMORY.md 200 lines/25 KB, skill description cap): −5, max −15",
+    "Each file the agent ignores (e.g. AGENTS.md under CLAUDE.md precedence, .md in .cursor/rules): −3, max −9",
+    "Each near-duplicate file pair (≥60% shared text): −5, max −10",
+    "Letters: A ≥ 90 · B ≥ 80 · C ≥ 70 · D ≥ 60 · F below",
+    "Unmeasured always-loaded items (e.g. MCP servers) are NOT scored (we don't punish what we can't see). The grade is marked provisional, and an A is capped at B, because a top grade cannot be certified for a setup we could only partly see.",
+    "No grade at all is printed when nothing that loads up front was measured.",
+];
+function gradeAgent(ag, findings, window) {
+    const reasons = [];
+    let score = 100;
+    const always = ag.totals.always.est;
+    const share = (always / window) * 100;
+    const shareCost = share >= 20 ? 45 : share >= 10 ? 30 : share >= 5 ? 15 : share >= 2 ? 5 : 0;
+    if (shareCost) {
+        score -= shareCost;
+        reasons.push(`always-on is ~${share.toFixed(1)}% of the window (−${shareCost})`);
+    }
+    const mine = findings.filter((f) => f.agent === ag.id || f.agent === "all");
+    const count = (pred) => mine.filter(pred).length;
+    const long = count((f) => f.id === "F1");
+    const trunc = count((f) => f.id === "F4" || f.id === "F8" || f.id === "F12");
+    const ignored = count((f) => f.id === "F7" || f.id === "F11");
+    const dup = count((f) => f.id === "F2" && !f.data?.omittedPairs);
+    const apply = (n, per, max, why) => {
+        if (!n)
+            return;
+        const c = Math.min(max, n * per);
+        score -= c;
+        reasons.push(`${n} ${why} (−${c})`);
+    };
+    apply(long, 5, 15, "file(s) over the documented length guideline");
+    apply(trunc, 5, 15, "silent truncation(s)");
+    apply(ignored, 3, 9, "ignored file(s)");
+    apply(dup, 5, 10, "duplicate pair(s)");
+    score = Math.max(0, score);
+    let letter = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+    const unm = ag.totals.always.unmeasuredItems;
+    const partial = ag.lowerBound && unm === 0; // the scan budget cut the scan short
+    let cappedAt;
+    if (ag.lowerBound && letter === "A") {
+        // An "A" would claim a clean bill of health for a setup we could only partly see.
+        letter = "B";
+        cappedAt = "B";
+        reasons.push(partial ? "capped at B: the scan stopped at its budget, so a top grade cannot be certified" : `capped at B: ${unm} always-loaded item${unm > 1 ? "s" : ""} could not be measured, so a top grade cannot be certified`);
+    }
+    return { letter, score, provisional: ag.lowerBound, ...(cappedAt ? { cappedAt } : {}), reasons };
+}

package/dist/analyze/savings.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CUT_N = void 0;
+exports.cutCandidates = cutCandidates;
+exports.cutCandidatesWithSource = cutCandidatesWithSource;
+exports.savingsOf = savingsOf;
+exports.cardTiles = cardTiles;
+const fmt_1 = require("../util/fmt");
+/** Default number of groups in the "what to cut" line. */
+exports.DEFAULT_CUT_N = 3;
+/** Below this the cut list is noise, not advice. */
+const MIN_SAVINGS_TOKENS = 500;
+/**
+ * Things a person can actually remove and that cost tokens before the first message: a plugin's skills, a skills folder,
+ * an MCP server with a measured size. Instruction files and rules are NOT candidates (they are your own words; use the findings for those).
+ */
+function cutCandidates(items) {
+    return cutCandidatesWithSource(items).map(({ source: _source, ...c }) => c);
+}
+/** Same list, same order as cutCandidates(), plus the item each group came from (for renderers that need its scope / file). */
+function cutCandidatesWithSource(items) {
+    const out = [];
+    for (const it of items) {
+        if (it.loadMode !== "always" || !it.tokens || it.tokens.est <= 0)
+            continue;
+        if (it.kind === "skills-listing" && it.parts?.length) {
+            for (const p of it.parts)
+                out.push({ label: p.name, kind: "skills", tokens: p.tokens, count: p.count, source: it });
+        }
+        else if (it.kind === "skills-listing") {
+            out.push({ label: it.label.replace(/^Skills listing \((.*)\)$/, "$1"), kind: "skills", tokens: it.tokens.est, count: 1, source: it });
+        }
+        else if (it.kind === "mcp-server" && it.server) {
+            out.push({ label: `MCP server ${it.server.name}`, kind: "mcp", tokens: it.tokens.est, count: 1, source: it });
+        }
+    }
+    return out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label));
+}
+/** What removing the top `n` groups would save (estimate). Null when there is nothing meaningful to say. */
+function savingsOf(items, alwaysEst, window, n = exports.DEFAULT_CUT_N) {
+    const cands = cutCandidates(items);
+    if (!cands.length || alwaysEst <= 0)
+        return null;
+    const top = cands.slice(0, n);
+    const topTokens = top.reduce((s, c) => s + c.tokens, 0);
+    if (topTokens < MIN_SAVINGS_TOKENS)
+        return null;
+    const groupsTokens = cands.reduce((s, c) => s + c.tokens, 0);
+    return {
+        n: top.length,
+        top,
+        topTokens,
+        groupsTokens,
+        groupsCount: cands.length,
+        pctOfAlways: (topTokens / alwaysEst) * 100,
+        pctOfGroups: groupsTokens ? (topTokens / groupsTokens) * 100 : 0,
+        pctOfWindow: (topTokens / window) * 100,
+    };
+}
+/** A tile label must never read like a path: drop any word that looks like one ("3 legacy ~/.codex skills" -> "3 legacy skills"). */
+function pathFree(label) {
+    const words = label.split(/\s+/).filter((w) => w && !/[\\/~]/.test(w));
+    return words.join(" ") || "skills";
+}
+/**
+ * Always-on tiles for the card treemap. Skills listings and MCP servers are expanded into the SAME groups as the cut list
+ * (cutCandidates), so the card matches its headline; everything else keeps its generic card label ("rule file 2").
+ * Sorted by size. `anonymize` replaces plugin and MCP server names with "plugin 2" / "MCP server 1".
+ */
+function cardTiles(items, anonymize = false) {
+    const out = [];
+    cutCandidates(items).forEach((c, k) => {
+        const named = c.kind === "mcp" || /^plugin /.test(c.label);
+        out.push({ label: named ? c.label : pathFree(c.label), tokens: c.tokens, kind: c.kind === "mcp" ? "mcp" : "group", named, cut: k });
+    });
+    // Always-on items that are not removable groups: repeated generic labels collapse into one tile ("rule file x14"), not 14 slivers.
+    const plain = items.filter((i) => i.loadMode === "always" && i.tokens && i.tokens.est > 0 && i.kind !== "mcp-server" && i.kind !== "skills-listing");
+    const byLabel = new Map();
+    for (const it of plain) {
+        const g = byLabel.get(it.cardLabel) ?? { n: 0, tokens: 0 };
+        g.n++;
+        g.tokens += it.tokens.est;
+        byLabel.set(it.cardLabel, g);
+    }
+    for (const [label, g] of byLabel)
+        out.push({ label: g.n > 1 ? `${label} x${g.n}` : label, tokens: g.tokens, kind: "item", named: false });
+    out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label));
+    if (anonymize) {
+        let plugins = 0;
+        let servers = 0;
+        for (const t of out) {
+            if (!t.named)
+                continue;
+            t.label = t.kind === "mcp" ? `MCP server ${++servers}` : `plugin ${++plugins}`;
+            t.named = false;
+        }
+    }
+    // identical labels (two "3 user skills" groups, two servers with the same name) must stay distinguishable
+    const dup = new Map();
+    for (const t of out)
+        dup.set(t.label, (dup.get(t.label) ?? 0) + 1);
+    const idx = new Map();
+    for (const t of out) {
+        if ((dup.get(t.label) ?? 1) > 1) {
+            const k = (idx.get(t.label) ?? 0) + 1;
+            idx.set(t.label, k);
+            t.label = `${t.label} (${k})`;
+        }
+    }
+    return out;
+}

package/dist/analyze/summary.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageOf = coverageOf;
+exports.mcpServersOf = mcpServersOf;
+exports.offendersOf = offendersOf;
+const fmt_1 = require("../util/fmt");
+/** What the scan measured vs. could not measure among always-on items. Counts only; no content. */
+function coverageOf(agent, items) {
+    const always = items.filter((i) => i.loadMode === "always");
+    const measuredKinds = {};
+    const unmeasuredKinds = {};
+    let m = 0;
+    let u = 0;
+    for (const it of always) {
+        if (it.tokens) {
+            m++;
+            measuredKinds[it.kind] = (measuredKinds[it.kind] ?? 0) + 1;
+        }
+        else {
+            u++;
+            unmeasuredKinds[it.kind] = (unmeasuredKinds[it.kind] ?? 0) + 1;
+        }
+    }
+    const servers = new Set(items.filter((i) => i.server).map((i) => `${i.server.name}|${i.path}|${i.scope}`));
+    return { agent, alwaysMeasuredItems: m, alwaysUnmeasuredItems: u, alwaysFraction: m + u ? m / (m + u) : null, measuredKinds, unmeasuredKinds, mcpServers: servers.size };
+}
+function mcpServersOf(items) {
+    const map = new Map();
+    for (const it of items) {
+        if (!it.server)
+            continue;
+        const key = `${it.server.name}|${it.path}|${it.scope}`;
+        const cur = map.get(key);
+        const measured = it.tokens !== null;
+        if (!cur)
+            map.set(key, { name: it.server.name, source: it.path, scope: it.scope, transport: it.server.transport, measured });
+        else
+            cur.measured = cur.measured && measured;
+    }
+    return [...map.values()].sort((a, b) => (0, fmt_1.cmp)(a.name, b.name) || (0, fmt_1.cmp)(a.source, b.source));
+}
+/** Heaviest always-on contributors. Aggregated listings (skills) are expanded into their biggest entries. */
+function offendersOf(agent, items, limit = 15) {
+    const out = [];
+    for (const it of items) {
+        if (it.loadMode !== "always" || !it.tokens)
+            continue;
+        if (it.breakdown && it.breakdown.length) {
+            for (const b of it.breakdown)
+                out.push({ agent, label: `skill "${b.label}"`, path: it.path, kind: it.kind, loadMode: it.loadMode, tokens: b.tokens, note: `inside ${it.label}` });
+        }
+        else {
+            out.push({ agent, label: it.label, path: it.path, kind: it.kind, loadMode: it.loadMode, tokens: it.tokens.est });
+        }
+    }
+    return out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label)).slice(0, limit);
+}

package/dist/analyze/totals.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumTotals = sumTotals;
+const model_1 = require("../model");
+function sumTotals(items) {
+    const out = {};
+    for (const m of model_1.LOAD_MODES)
+        out[m] = { est: 0, low: 0, high: 0, measuredItems: 0, unmeasuredItems: 0 };
+    for (const it of items) {
+        const t = out[it.loadMode];
+        if (!it.tokens) {
+            t.unmeasuredItems++;
+            continue;
+        }
+        t.est += it.tokens.est;
+        t.low += it.tokens.low;
+        t.high += it.tokens.high;
+        t.measuredItems++;
+    }
+    return out;
+}

package/dist/calibrate.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextParseError = void 0;
+exports.parseNumber = parseNumber;
+exports.parseContext = parseContext;
+exports.compare = compare;
+exports.renderCalibration = renderCalibration;
+exports.calibrationJson = calibrationJson;
+/**
+ * `prehello calibrate`: compare prehello's estimate with a Claude Code `/context` reading the user pasted. Offline: the text is
+ * parsed locally and nothing is sent anywhere. A file is written only with --save.
+ */
+const node_path_1 = __importDefault(require("node:path"));
+const families_1 = require("./tokens/families");
+const fmt_1 = require("./util/fmt");
+class ContextParseError extends Error {
+}
+exports.ContextParseError = ContextParseError;
+const NUM = String.raw `(\d[\d,]*(?:\.\d+)?)\s*([kKmM]?)`;
+function parseNumber(num, suffix) {
+    const n = parseFloat(num.replace(/,/g, ""));
+    const mult = suffix.toLowerCase() === "k" ? 1000 : suffix.toLowerCase() === "m" ? 1_000_000 : 1;
+    const decimals = num.includes(".") ? num.split(".")[1].length : 0;
+    const pm = (mult === 1 && decimals === 0 ? 0.5 : 0.5 * Math.pow(10, -decimals)) * mult;
+    return { value: Math.round(n * mult), pm: mult === 1 && decimals === 0 ? 0.5 : pm, raw: `${num}${suffix}` };
+}
+const KNOWN = ["system prompt", "system tools", "system tools (deferred)", "mcp tools", "mcp tools (deferred)", "custom agents", "memory files", "skills", "messages", "free space", "autocompact buffer"];
+const SECTIONS = [
+    [/^mcp tools\b/i, "mcp tools"],
+    [/^custom agents\b/i, "custom agents"],
+    [/^memory files\b/i, "memory files"],
+    [/^skills\b/i, "skills"],
+    [/^system tools\b/i, "system tools"],
+    [/^plugins?\b/i, "plugins"],
+];
+/** Parse the text of Claude Code's `/context` (any of the layouts seen 2025-2026). Unknown lines are ignored and counted. */
+function parseContext(text) {
+    // eslint-disable-next-line no-control-regex
+    const clean = text.replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, "").replace(/\r\n?/g, "\n");
+    const r = { categories: new Map(), details: new Map(), mcpOnDemand: false, recognised: 0, ignored: 0 };
+    let section;
+    const header = new RegExp(String.raw `([\w.\-\[\]]+)\s+·\s+${NUM}\s*/\s*${NUM}\s+tokens\s*\(`, "i");
+    const usedOnly = new RegExp(String.raw `^\s*${NUM}\s*/\s*${NUM}\s+tokens\s*\(`, "i");
+    const cat = new RegExp(String.raw `([A-Za-z][A-Za-z ]*?(?:\s*\((?:deferred)\))?):\s+${NUM}\s*(?:tokens)?\s*\(\s*\d+(?:\.\d+)?%\s*\)`, "g");
+    const row = new RegExp(String.raw `^\s*[└├│]?[─\s]*└?\s*(.+?):\s+${NUM}\s+tokens\s*$`);
+    const summary = new RegExp(String.raw `^\s*└\s+\d[\d,]*\s+\w+\s+·\s+${NUM}\s+tokens`);
+    for (const line0 of clean.split("\n")) {
+        const line = line0.replace(/[⛁⛀⛶⛝⛃]/g, " ").replace(/^\s*(?:❯|>)?\s*(?:⎿)?\s*/, "");
+        if (!line.trim())
+            continue;
+        const h = header.exec(line);
+        if (h) {
+            r.model = h[1];
+            r.used = parseNumber(h[2], h[3]);
+            r.total = parseNumber(h[4], h[5]);
+            r.recognised++;
+            continue;
+        }
+        const u = usedOnly.exec(line);
+        if (u) {
+            r.used = parseNumber(u[1], u[2]);
+            r.total = parseNumber(u[3], u[4]);
+            r.recognised++;
+            continue;
+        }
+        if (/^\s*claude-[\w.\-\[\]]+\s*$/i.test(line)) {
+            r.model = line.trim();
+            r.recognised++;
+            continue;
+        }
+        let anyCat = false;
+        for (const m of line.matchAll(cat)) {
+            const name = m[1].trim().toLowerCase().replace(/\s+/g, " ");
+            if (!KNOWN.includes(name) && !/^[a-z ]+( \(deferred\))?$/.test(name))
+                continue;
+            r.categories.set(name, parseNumber(m[2], m[3]));
+            anyCat = true;
+        }
+        if (anyCat) {
+            r.recognised++;
+            section = undefined;
+            continue;
+        }
+        const sec = line.trim();
+        const sm = SECTIONS.find(([re]) => re.test(sec) && /·|\/\w/.test(sec));
+        if (sm) {
+            section = sm[1];
+            if (section === "mcp tools" && /on-demand|deferred/i.test(sec))
+                r.mcpOnDemand = true;
+            if (!r.details.has(section))
+                r.details.set(section, []);
+            r.recognised++;
+            continue;
+        }
+        if (section && summary.test(line)) {
+            r.recognised++;
+            continue;
+        }
+        const rw = section ? row.exec(line) : null;
+        if (rw && section) {
+            const label = rw[1].replace(/^[└├│─\s]+/, "").trim();
+            const pm = /\(([^()]*[\/\\][^()]*)\)\s*$/.exec(label);
+            const p = pm ? pm[1] : /[\/\\]/.test(label) ? label : undefined;
+            r.details.get(section).push({ label, tokens: parseNumber(rw[2], rw[3]), ...(p ? { path: p } : {}) });
+            r.recognised++;
+            continue;
+        }
+        if (section && /^\s*(User|Project|Local|Managed|Plugin|Built-in|Enterprise)\b[^:]*$/i.test(line)) {
+            r.recognised++;
+            continue;
+        }
+        r.ignored++;
+    }
+    if (!r.categories.size) {
+        throw new ContextParseError("no /context category rows found (expected lines like 'Memory files: 3.2k tokens (1.6%)'). Paste the whole output of /context (or /context all) from Claude Code");
+    }
+    return r;
+}
+const COMPARED = [
+    { cat: "memory files", kinds: ["instructions", "rule", "memory"] },
+    { cat: "skills", kinds: ["skills-listing"] },
+    { cat: "custom agents", kinds: ["subagents"] },
+    { cat: "mcp tools", kinds: ["mcp-server"] },
+];
+function mk(category, actual, est, unmeasured, note) {
+    const a = actual?.value ?? null;
+    const err = a !== null && a > 0 && est ? ((est.est - a) / a) * 100 : null;
+    const inBand = a !== null && est ? est.low <= a + (actual?.pm ?? 0) && est.high >= a - (actual?.pm ?? 0) : null;
+    return { category, actual: a, actualPm: actual?.pm ?? 0, est: est?.est ?? null, low: est?.low ?? null, high: est?.high ?? null, errorPct: err, inBand, unmeasuredItems: unmeasured, ...(note ? { note } : {}) };
+}
+function sumItems(items) {
+    const m = items.filter((i) => i.tokens);
+    if (!m.length)
+        return null;
+    return m.reduce((s, i) => ({ est: s.est + i.tokens.est, low: s.low + i.tokens.low, high: s.high + i.tokens.high }), { est: 0, low: 0, high: 0 });
+}
+const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+function compare(reading, a, home) {
+    const always = a.items.filter((i) => i.loadMode === "always");
+    const rows = [];
+    const used = { est: 0, low: 0, high: 0, actual: 0, pm: 0, any: false };
+    for (const c of COMPARED) {
+        let items = always.filter((i) => c.kinds.includes(i.kind));
+        let actual = reading.categories.get(c.cat);
+        let note;
+        if (c.cat === "mcp tools") {
+            if (reading.mcpOnDemand || (!actual && reading.categories.has("mcp tools (deferred)")))
+                note = "Claude Code loads these tool schemas on demand (tool search); only the always-on part is compared";
+            if (!actual && items.length === 0)
+                continue;
+        }
+        if (!actual && !items.length)
+            continue;
+        const est = sumItems(items);
+        const unmeasured = items.filter((i) => !i.tokens).length;
+        if (unmeasured)
+            note = `${unmeasured} item(s) unmeasured by prehello: its number is a lower bound`;
+        if (!actual)
+            actual = { value: 0, pm: 0, raw: "absent" };
+        const row = mk(c.cat, actual, est ?? { est: 0, low: 0, high: 0 }, unmeasured, note ?? (reading.categories.has(c.cat) ? undefined : "/context shows no such row (treated as 0)"));
+        rows.push(row);
+        if (est) {
+            used.est += est.est;
+            used.low += est.low;
+            used.high += est.high;
+        }
+        used.actual += actual.value;
+        used.pm += actual.pm;
+        used.any = true;
+        items = [];
+    }
+    const total = mk("compared total", used.any ? { value: used.actual, pm: used.pm, raw: "" } : undefined, used.any ? used : null, rows.reduce((s, r) => s + r.unmeasuredItems, 0));
+    // per memory file, matched by path
+    const files = [];
+    const memItems = always.filter((i) => ["instructions", "rule", "memory"].includes(i.kind) && i.tokens);
+    for (const fr of reading.details.get("memory files") ?? []) {
+        if (!fr.path)
+            continue;
+        const p = norm(fr.path.startsWith("~") ? node_path_1.default.join(home, fr.path.slice(1)) : fr.path);
+        const hit = memItems.find((i) => norm(i.path) === p) ?? memItems.find((i) => p.endsWith("/" + norm(node_path_1.default.basename(i.path))) && norm(i.path).endsWith(p.split("/").slice(-2).join("/")));
+        if (hit)
+            files.push(mk(fr.path, fr.tokens, hit.tokens, 0));
+        else
+            files.push(mk(fr.path, fr.tokens, null, 0, "prehello did not find this file"));
+    }
+    const notEstimated = [];
+    for (const k of ["system prompt", "system tools", "messages"]) {
+        const v = reading.categories.get(k);
+        if (v)
+            notEstimated.push({ category: k, actual: v.value });
+    }
+    // implied ratio on markdown-like content: actual / raw o200k, where raw = est / factor
+    const f = (0, families_1.claudeCalibration)().byKind.markdown.factor * (a.profile.id === "claude-legacy" ? (0, families_1.claudeCalibration)().legacyRatio.value : 1);
+    const md = rows.filter((r) => r.category !== "mcp tools" && r.est && r.actual && r.unmeasuredItems === 0);
+    const mdEst = md.reduce((s, r) => s + (r.est ?? 0), 0);
+    const mdAct = md.reduce((s, r) => s + (r.actual ?? 0), 0);
+    const impliedMarkdownRatio = mdEst > 0 && mdAct > 0 ? Math.round(((mdAct * f) / mdEst) * 1000) / 1000 : null;
+    return { model: reading.model, rows, files, total, notEstimated, impliedMarkdownRatio, ignoredLines: reading.ignored };
+}
+const pctStr = (x) => (x === null ? "n/a" : `${x >= 0 ? "+" : ""}${x.toFixed(1)}%`);
+const cell = (n) => (n === null ? "-" : (0, fmt_1.fmtTok)(n));
+/** A memory-file label the reader can recognise: relative to the scanned folder when inside it, and never cut at the file name. */
+function fileLabel(p, cwd) {
+    const variants = (x) => [x, x.replace(/^\/private(?=\/)/, ""), `/private${x}`];
+    for (const base of variants(cwd)) {
+        for (const cand of variants(p)) {
+            const rel = node_path_1.default.relative(base, cand);
+            if (rel && !rel.startsWith("..") && !node_path_1.default.isAbsolute(rel))
+                return (0, fmt_1.shortenLabel)((0, fmt_1.sanitize)(rel, 1000), 70);
+        }
+    }
+    return (0, fmt_1.shortenLabel)((0, fmt_1.sanitize)(p, 1000), 70);
+}
+function renderCalibration(c, r) {
+    const out = [];
+    out.push(`prehello ${r.tool.version} calibrate · Claude Code${c.model ? ` · /context model ${(0, fmt_1.sanitize)(c.model, 60)}` : ""}`);
+    out.push("Compares prehello's always-on estimate with your /context reading (offline; nothing is sent anywhere).", "");
+    const head = ["category", "/context", "prehello (low-high)", "error", "in band"];
+    const lines = [...c.rows, c.total].map((x) => [x.category, cell(x.actual), x.est === null ? "-" : `${(0, fmt_1.fmtTok)(x.est)} (${(0, fmt_1.fmtTok)(x.low)}-${(0, fmt_1.fmtTok)(x.high)})`, pctStr(x.errorPct), x.inBand === null ? "-" : x.inBand ? "yes" : "NO"]);
+    const w = head.map((h, i) => Math.max(h.length, ...lines.map((l) => l[i].length)));
+    const fmtRow = (l) => "  " + l.map((s, i) => (i === 0 ? s.padEnd(w[i]) : s.padStart(w[i]))).join("  ");
+    out.push(fmtRow(head));
+    for (const l of lines)
+        out.push(fmtRow(l));
+    for (const x of c.rows)
+        if (x.note)
+            out.push(`  note (${x.category}): ${x.note}`);
+    if (c.files.length) {
+        out.push("", "Memory files, one by one:");
+        for (const f of c.files)
+            out.push(`  ${fileLabel(f.category, r.scan.cwd)}: /context ${cell(f.actual)}, prehello ${cell(f.est)}, error ${pctStr(f.errorPct)}${f.note ? ` (${f.note})` : ""}`);
+    }
+    if (c.notEstimated.length)
+        out.push("", `Not estimated by prehello (built into Claude Code): ${c.notEstimated.map((n) => `${n.category} ${(0, fmt_1.fmtTok)(n.actual)}`).join(", ")}.`);
+    if (c.total.errorPct !== null && Math.abs(c.total.errorPct) > 50)
+        out.push("", "The numbers are far apart. Run /context in a fresh Claude Code session started in the folder prehello scans (pass that folder as [path]), and paste its whole output.");
+    if (c.impliedMarkdownRatio !== null && c.impliedMarkdownRatio > 0.5 && c.impliedMarkdownRatio < 3)
+        out.push(`Implied Claude/o200k ratio for text here: ${c.impliedMarkdownRatio} (prehello uses ${(0, families_1.claudeCalibration)().byKind.markdown.factor}; includes listing wrappers).`);
+    out.push("/context rounds its numbers (2.8k = 2,750-2,849); 'in band' allows for that.");
+    if (c.ignoredLines)
+        out.push(`${c.ignoredLines} line(s) of the pasted text were not recognised and ignored.`);
+    out.push("Share it: prehello calibrate --file ctx.txt --save calibration.json, then attach the file to an issue (no paths or names in it).");
+    return out.join("\n") + "\n";
+}
+/** Redacted record: no paths, no names. */
+function calibrationJson(c, r, a, redact) {
+    return {
+        tool: { name: "prehello", version: r.tool.version },
+        kind: "calibration",
+        generatedAt: r.generatedAt,
+        agent: a.id,
+        profile: a.profile.id,
+        model: c.model ?? null,
+        calibration: { measuredAt: (0, families_1.claudeCalibration)().measuredAt, markdownFactor: (0, families_1.claudeCalibration)().byKind.markdown.factor, jsonFactor: (0, families_1.claudeCalibration)().byKind.json.factor },
+        rows: c.rows,
+        total: c.total,
+        files: redact ? c.files.map(({ category: _c, ...rest }, i) => ({ category: `memory file ${i + 1}`, ...rest })) : c.files,
+        notEstimated: c.notEstimated,
+        impliedMarkdownRatio: c.impliedMarkdownRatio,
+        ignoredLines: c.ignoredLines,
+    };
+}