segreant 0.1.0 → 0.2.0

package/dist/connect/importShared.js

@@ -12,7 +12,7 @@
 import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { RequestObservationConflictError } from '../store/db.js';
-import { repoToplevel } from '../git/correlate.js';
+import { repoToplevelOnDisk } from './repoRoot.js';
 import { projectKey, projectKeyWithBasis } from '../value/characterization.js';
 import { RESOURCE_LIMITS } from '../util/resource-limits.js';
 export function emptyImportSummary(files = 0) {
@@ -76,6 +76,49 @@ export function boundedJsonlFiles(root) {
     }
     return { files, truncated };
 }
+/**
+ * The version of what the importers read from a log file. A file read in full
+ * by an older reader is read once more: version 2 added commit observations;
+ * version 4 finds them only where git's own output starts (see COMMIT_START).
+ */
+export const IMPORT_READER_VERSION = 4;
+// git prints "[main 3f60dcf] subject" when it creates a commit, "[main
+// (root-commit) 3f60dcf] subject" for the first one, and "[detached HEAD
+// 3f60dcf] subject" off a branch. In a JSON log line the subject ends at an
+// escaped newline or the closing quote of the string.
+const COMMIT_LINE = /\[((?:detached HEAD)|[A-Za-z0-9._\/-]{1,120})(?: \(root-commit\))? ([0-9a-f]{7,40})\] ((?:[^"\\]|\\[^n]){1,200})/g;
+/**
+ * Where git's own output can begin in a raw log line: the start of a JSON
+ * string value (`"content":"`, `"stdout":"`, `"output":"`, at any escaping
+ * depth) or an escaped newline inside one. A commit line anywhere else is
+ * TEXT ABOUT a commit: a test fixture `content: '[main abc1234] ...'` that an
+ * agent read or wrote, or a comment explaining the format. On the owner's real
+ * logs (2026-10-16) the rule kept all 127 real matches and rejected all 26 of
+ * those, which had been recorded as commits the sessions made.
+ */
+const COMMIT_START = /(?:(?:^|[:\[,]\s*)\\*"|\\+n)$/;
+/** Every commit-creation line in one raw (JSON-encoded) log line. */
+export function commitObservationsInLine(line) {
+    if (!line.includes('] '))
+        return [];
+    const found = [];
+    for (const m of line.matchAll(COMMIT_LINE)) {
+        if (!COMMIT_START.test(line.slice(Math.max(0, m.index - 16), m.index)))
+            continue;
+        let subject = m[3];
+        try {
+            subject = JSON.parse(`"${subject}"`);
+        }
+        catch { /* keep the raw text */ }
+        subject = subject.trim();
+        if (subject.length === 0)
+            continue;
+        if (found.some((f) => f.shortSha === m[2]))
+            continue;
+        found.push({ branch: m[1], shortSha: m[2], subject });
+    }
+    return found;
+}
 /**
  * Decide whether a tool log file needs reading. Returns 'unchanged' when its
  * size and mtime match the last COMPLETE import of it into this ledger, its
@@ -91,10 +134,14 @@ export function fileStampForImport(store, source, file, opts) {
     catch {
         return null;
     }
+    if (opts.modifiedSinceMs !== undefined && stamp.mtimeMs < opts.modifiedSinceMs)
+        return 'deferred';
     if (opts.rescan)
         return stamp;
     const last = store.importFileCursor(source, file);
-    return last !== null && last.size === stamp.size && last.mtimeMs === stamp.mtimeMs ? 'unchanged' : stamp;
+    return last !== null && last.readerVersion === IMPORT_READER_VERSION && last.size === stamp.size && last.mtimeMs === stamp.mtimeMs
+        ? 'unchanged'
+        : stamp;
 }
 /**
  * Account for a skipped file: count it, and replay the truncation its last full
@@ -126,6 +173,7 @@ export function noteFileImported(store, source, file, stamp, opts, before, summa
         mtimeMs: stamp.mtimeMs,
         truncatedLines: now.lines - before.lines,
         truncatedRows: now.rows - before.rows,
+        readerVersion: IMPORT_READER_VERSION,
     });
 }
 /** Mark a source import as incomplete without changing its accounting rows. */
@@ -197,9 +245,13 @@ export function recordInsert(store, summary, row, estimated) {
  * of nearly lining up.
  *
  * When the path is not inside a repository (a scratch folder, a deleted
- * directory, no git on PATH), this degrades to exactly the previous behaviour
+ * directory), this degrades to exactly the previous behaviour
  * and says so through the basis. Results are cached per directory: a transcript
  * corpus has thousands of lines and a handful of distinct working directories.
+ *
+ * The root is found on disk (`repoToplevelOnDisk`), the way git discovers it,
+ * rather than by running git: one spawn per directory cost about 45 ms on
+ * Windows, in every importer, on every refresh.
  */
 export function createRepoResolver() {
     const cache = new Map();
@@ -207,11 +259,11 @@ export function createRepoResolver() {
         const inferred = projectKeyWithBasis(cwd, fallback);
         if (!cwd || inferred.basis === 'tool_log_fallback')
             return { ...inferred, supersedes: null };
-        const key = `${cwd}${fallback}`;
+        const key = `${cwd}\0${fallback}`;
         const hit = cache.get(key);
         if (hit)
             return hit;
-        const top = await repoToplevel(cwd);
+        const top = repoToplevelOnDisk(cwd);
         const resolved = top === null
             ? { ...inferred, supersedes: null }
             : {
@@ -227,4 +279,5 @@ export const IMPORTERS = [
     { id: 'claude-code', label: 'Claude Code', blurb: 'Exact per-request usage from ~/.claude transcripts — works on Pro/Max subscriptions.' },
     { id: 'opencode', label: 'opencode', blurb: "Token usage from opencode's local session database (all providers it ran)." },
     { id: 'codex', label: 'Codex CLI', blurb: 'Per-turn token usage from ~/.codex rollout session logs.' },
+    { id: 'antigravity', label: 'Antigravity', blurb: 'Per-call token usage from the conversation databases Antigravity and the agy CLI keep under ~/.gemini.' },
 ];

package/dist/connect/opencode.js

@@ -62,8 +62,14 @@ export function parseOpencodeMessage(id, dataJson, fallbackTsMs) {
     if (input === 0 && output === 0 && reasoning === 0 && cacheRead === 0 && cacheWrite === 0)
         return null;
     const ts = d.time?.created ?? fallbackTsMs;
-    if (typeof ts !== 'number' || !Number.isFinite(ts))
+    // Missing dates cannot be placed in a reporting period. Zero is OpenCode's
+    // unknown sentinel, not evidence that the request happened in January 1970.
+    if (typeof ts !== 'number' || !Number.isFinite(ts) || ts <= 0 || ts > 8.64e15)
         return null;
+    // An explicit zero is a valid free-tier report. An absent or malformed price
+    // is not a reported zero: it stays unknown here, and the importer prices the
+    // tokens with a stated basis or leaves the row out.
+    const reportedCostUsd = typeof d.cost === 'number' && Number.isFinite(d.cost) && d.cost >= 0 ? d.cost : null;
     const cwd = d.path?.cwd ?? '';
     const { project, basis: attributionBasis } = projectKeyWithBasis(cwd, 'opencode');
     return {
@@ -80,7 +86,7 @@ export function parseOpencodeMessage(id, dataJson, fallbackTsMs) {
         reasoningTokens: reasoning,
         cacheReadTokens: cacheRead,
         cacheWriteTokens: cacheWrite,
-        reportedCostUsd: typeof d.cost === 'number' && d.cost >= 0 ? d.cost : 0,
+        reportedCostUsd,
     };
 }
 /** opencode provider ids that our own rate card can price exactly. */
@@ -132,21 +138,43 @@ function importOpencodeRows(store, opts) {
             // OpenCode supplies this number; Segreant records it as tool-reported rather
             // than calling it an invoice. Only a zero amount with an exact local match
             // is replaced by a local list-price calculation.
-            let costUsd = ev.reportedCostUsd;
+            let costUsd;
             let estimated = false;
             let pricing = toolReportedPricingEvidence();
             let economicAmount;
-            if (costUsd === 0 && REPRICEABLE[ev.provider]) {
-                const c = computeCost(REPRICEABLE[ev.provider], ev.model, {
+            if (ev.reportedCostUsd === null) {
+                // No reported cost. The tokens are still real usage, so price them the
+                // way the proxy would: the list rate when the model is listed, otherwise
+                // a fallback marked estimated. A provider with no list price at all has
+                // nothing honest to price with, and the row stays out of the totals.
+                const provider = REPRICEABLE[ev.provider];
+                if (!provider)
+                    continue;
+                const c = computeCost(provider, ev.model, {
                     inputTokens: ev.inputTokens,
                     outputTokens: ev.outputTokens,
                     cacheWriteTokens: ev.cacheWriteTokens,
                     cacheReadTokens: ev.cacheReadTokens,
                 });
-                if (!c.estimated) {
-                    costUsd = c.costUsd; // only adopt an EXACT match; never the fallback rate
-                    pricing = c.pricing;
-                    economicAmount = c.exact?.total;
+                costUsd = c.costUsd;
+                estimated = c.estimated;
+                pricing = c.pricing;
+                economicAmount = c.exact?.total;
+            }
+            else {
+                costUsd = ev.reportedCostUsd;
+                if (costUsd === 0 && REPRICEABLE[ev.provider]) {
+                    const c = computeCost(REPRICEABLE[ev.provider], ev.model, {
+                        inputTokens: ev.inputTokens,
+                        outputTokens: ev.outputTokens,
+                        cacheWriteTokens: ev.cacheWriteTokens,
+                        cacheReadTokens: ev.cacheReadTokens,
+                    });
+                    if (!c.estimated) {
+                        costUsd = c.costUsd; // only adopt an EXACT match; never the fallback rate
+                        pricing = c.pricing;
+                        economicAmount = c.exact?.total;
+                    }
                 }
             }
             const row = {

package/dist/connect/protobuf.js

@@ -0,0 +1,126 @@
+/**
+ * A minimal protobuf wire-format reader: enough to pull known fields out of a
+ * message whose schema is published, without a runtime dependency. It reads
+ * varints, length-delimited fields and fixed 32/64-bit fields, and stops at the
+ * first malformed byte rather than guessing.
+ */
+/** All fields of one message, by field number, in wire order. Malformed input yields what parsed cleanly. */
+export function pbFields(buf) {
+    const out = new Map();
+    let pos = 0;
+    const varint = () => {
+        let result = 0n;
+        let shift = 0n;
+        while (pos < buf.length) {
+            const b = buf[pos++];
+            result |= BigInt(b & 0x7f) << shift;
+            if ((b & 0x80) === 0)
+                return result;
+            shift += 7n;
+            if (shift > 70n)
+                return null;
+        }
+        return null;
+    };
+    while (pos < buf.length) {
+        const key = varint();
+        if (key === null)
+            break;
+        const field = Number(key >> 3n);
+        const wire = Number(key & 7n);
+        if (field <= 0)
+            break;
+        let v;
+        if (wire === 0) {
+            const n = varint();
+            if (n === null)
+                break;
+            v = { wire: 0, value: n };
+        }
+        else if (wire === 2) {
+            const len = varint();
+            if (len === null || pos + Number(len) > buf.length)
+                break;
+            v = { wire: 2, bytes: buf.subarray(pos, pos + Number(len)) };
+            pos += Number(len);
+        }
+        else if (wire === 1 || wire === 5) {
+            const size = wire === 1 ? 8 : 4;
+            if (pos + size > buf.length)
+                break;
+            v = { wire, bytes: buf.subarray(pos, pos + size) };
+            pos += size;
+        }
+        else {
+            break; // groups (3/4) are not used by the schemas read here
+        }
+        const list = out.get(field) ?? [];
+        list.push(v);
+        out.set(field, list);
+    }
+    return out;
+}
+/** The first varint of a field as a safe number (0 when absent or too large). */
+export function pbUint(fields, field) {
+    const v = fields.get(field)?.find((x) => x.wire === 0);
+    if (v === undefined || v.wire !== 0)
+        return 0;
+    return v.value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v.value) : 0;
+}
+/** The first length-delimited field's bytes, or null. */
+export function pbBytes(fields, field) {
+    const v = fields.get(field)?.find((x) => x.wire === 2);
+    return v !== undefined && v.wire === 2 ? v.bytes : null;
+}
+/** The first length-delimited field as UTF-8 text, or null. */
+export function pbString(fields, field) {
+    const b = pbBytes(fields, field);
+    return b === null ? null : Buffer.from(b).toString('utf8');
+}
+/** A nested message's fields, or null. */
+export function pbMessage(fields, field) {
+    const b = pbBytes(fields, field);
+    return b === null ? null : pbFields(b);
+}
+/** Every varint of a field, including a packed repeated field. */
+export function pbUints(fields, field) {
+    const out = [];
+    for (const v of fields.get(field) ?? []) {
+        if (v.wire === 0)
+            out.push(Number(v.value));
+        else if (v.wire === 2)
+            out.push(...packedVarints(v.bytes)); // packed: varints with no keys
+    }
+    return out;
+}
+function packedVarints(bytes) {
+    const out = [];
+    let pos = 0;
+    while (pos < bytes.length) {
+        let result = 0n;
+        let shift = 0n;
+        let done = false;
+        while (pos < bytes.length) {
+            const b = bytes[pos++];
+            result |= BigInt(b & 0x7f) << shift;
+            if ((b & 0x80) === 0) {
+                done = true;
+                break;
+            }
+            shift += 7n;
+        }
+        if (!done)
+            break;
+        out.push(Number(result));
+    }
+    return out;
+}
+/** A google.protobuf.Timestamp message as epoch milliseconds, or null. */
+export function pbTimestampMs(ts) {
+    if (ts === null)
+        return null;
+    const seconds = pbUint(ts, 1);
+    if (seconds === 0)
+        return null;
+    return seconds * 1000 + Math.floor(pbUint(ts, 2) / 1_000_000);
+}

package/dist/connect/registry.js

@@ -0,0 +1,46 @@
+/**
+ * The one list of native importers.
+ *
+ * The CLI and the dashboard each kept their own list. The CLI's gained
+ * Antigravity; the dashboard's did not, so "import all" from the dashboard
+ * silently skipped a tool the CLI read and `scan` reported (H008). Every
+ * surface now builds from this list: adding a tool is adding one entry here.
+ */
+import { existsSync } from 'node:fs';
+import { IMPORTERS } from './importShared.js';
+import { importClaudeCode, defaultClaudeCodeRoot } from './claudeCode.js';
+import { importOpencode, defaultOpencodeDbPath } from './opencode.js';
+import { importCodex, defaultCodexRoot } from './codex.js';
+import { importAntigravity, defaultAntigravityRoot } from './antigravity.js';
+const info = (id) => {
+    const found = IMPORTERS.find((i) => i.id === id);
+    if (!found)
+        throw new Error(`importer ${id} has no description in importShared IMPORTERS`);
+    return { label: found.label, blurb: found.blurb };
+};
+export const IMPORT_REGISTRY = [
+    {
+        id: 'claude-code', ...info('claude-code'), aliases: ['claude-code', 'claudecode', 'claude'],
+        locate: () => (existsSync(defaultClaudeCodeRoot()) ? defaultClaudeCodeRoot() : null),
+        run: (store, opts) => importClaudeCode(store, opts), recentFirst: true,
+    },
+    {
+        id: 'opencode', ...info('opencode'), aliases: ['opencode'],
+        locate: () => defaultOpencodeDbPath(),
+        run: (store, opts) => importOpencode(store, opts), recentFirst: false,
+    },
+    {
+        id: 'codex', ...info('codex'), aliases: ['codex', 'codex-cli'],
+        locate: () => defaultCodexRoot(),
+        run: (store, opts) => importCodex(store, opts), recentFirst: true,
+    },
+    {
+        id: 'antigravity', ...info('antigravity'), aliases: ['antigravity', 'agy', 'gemini'],
+        locate: () => defaultAntigravityRoot(),
+        run: (store, opts) => importAntigravity(store, opts), recentFirst: true,
+    },
+];
+export function importerFor(what) {
+    const w = what.toLowerCase();
+    return IMPORT_REGISTRY.find((e) => e.aliases.includes(w)) ?? null;
+}

package/dist/connect/repoRoot.js

@@ -0,0 +1,112 @@
+/**
+ * The git working tree a directory belongs to, found on disk the way git's own
+ * discovery finds it, without starting a process.
+ *
+ * Import attribution used to ask `git rev-parse --show-toplevel` once per
+ * distinct working directory. On Windows each spawn costs about 45 ms, so a
+ * corpus that touched 54 directories spent 2.6 s of a 5.3 s import waiting on
+ * git, in every importer, on every refresh. A CPU profile shows that wait as
+ * idle time, which is why it never stood out.
+ *
+ * Git walks up from the directory and stops at the first ancestor that holds
+ * either a `.git` directory it recognises as a repository or a `.git` file
+ * whose `gitdir:` line names an existing directory (a linked worktree or a
+ * submodule). This does the same, from the physical path, and returns the
+ * result in git's format: forward slashes on Windows, symlinks resolved, the
+ * on-disk letter case.
+ *
+ * Where this can differ from git, and why that is acceptable for a label:
+ * - git refuses a repository owned by another user (`safe.directory`); this
+ *   still finds its root. The label is the repository's name either way.
+ * - `GIT_DIR`, `GIT_WORK_TREE`, `GIT_CEILING_DIRECTORIES` and `core.worktree`
+ *   are not consulted. A tool's session directory does not set them.
+ * - a bare repository, or the inside of a `.git` folder, has no work tree:
+ *   git and this both return null there.
+ * The basis recorded with the label stays an inference (see CONTEXT.md).
+ */
+import { closeSync, openSync, readSync, realpathSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+/** The first line of a small pointer file (`.git`, `commondir`), or null. */
+function firstLine(file) {
+    let fd = null;
+    try {
+        fd = openSync(file, 'r');
+        const buf = Buffer.alloc(4096);
+        const n = readSync(fd, buf, 0, buf.length, 0);
+        return (buf.toString('utf8', 0, n).split(/\r?\n/, 1)[0] ?? '').trim();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            closeSync(fd);
+    }
+}
+/** A path written inside a git pointer file is relative to that file's folder. */
+function fromPointer(file, target) {
+    return isAbsolute(target) ? target : resolve(dirname(file), target);
+}
+/**
+ * git's own minimum for a directory to count as a repository: a HEAD, plus
+ * objects and refs. A linked worktree's git directory keeps those two in the
+ * main repository and names it in a `commondir` file.
+ */
+function isGitDirectory(dir) {
+    try {
+        if (!statSync(join(dir, 'HEAD')).isFile())
+            return false;
+        const common = firstLine(join(dir, 'commondir'));
+        const shared = common ? fromPointer(join(dir, 'commondir'), common) : dir;
+        return statSync(join(shared, 'objects')).isDirectory() && statSync(join(shared, 'refs')).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** A `.git` file names the real git directory: "gitdir: <path>". */
+function gitFileTarget(file) {
+    const m = /^gitdir: (.+)$/.exec(firstLine(file) ?? '');
+    return m ? fromPointer(file, m[1].trim()) : null;
+}
+function gitFormat(path) {
+    return process.platform === 'win32' ? path.replace(/\\/g, '/') : path;
+}
+export function repoToplevelOnDisk(dir) {
+    let current;
+    try {
+        // .native keeps the on-disk case on Windows and macOS, as git reports it.
+        current = realpathSync.native(dir);
+        if (!statSync(current).isDirectory())
+            return null;
+    }
+    catch {
+        return null; // a deleted or unreadable directory: git fails here too
+    }
+    for (;;) {
+        const marker = join(current, '.git');
+        let kind = null;
+        try {
+            const st = statSync(marker);
+            kind = st.isDirectory() ? 'dir' : st.isFile() ? 'file' : null;
+        }
+        catch {
+            kind = null;
+        }
+        if (kind === 'dir' && isGitDirectory(marker))
+            return gitFormat(current);
+        if (kind === 'file') {
+            // A broken pointer is fatal to git; it does not keep looking further up.
+            const target = gitFileTarget(marker);
+            return target !== null && isGitDirectory(target) ? gitFormat(current) : null;
+        }
+        // Inside a git directory itself (a bare repository, or a `.git` folder):
+        // git finds the repository but there is no work tree to name.
+        if (isGitDirectory(current))
+            return null;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/cost/basis.js

@@ -0,0 +1,168 @@
+/**
+ * How a total was priced, in parts — the one basis read model for every surface.
+ *
+ * The ledger records, per request, what kind of number its amount is (cost
+ * basis) and how its model was matched against the rate card. Totals used to
+ * throw that away: `today`, `week` and `month` called every dollar "priced from
+ * the rate card", so an amount opencode reported for a model the card does not
+ * know was printed as API list price, and a model missing from the card (priced
+ * at the generic fallback rate) sat inside a headline with nothing to say so.
+ *
+ * `summarizeBasis` keeps the parts. Every surface prints a total together with
+ * the cohorts that make it up, and the headline word follows the weakest part:
+ * a total is "list cost" only when every dollar in it was priced from a model's
+ * own rate on the card.
+ *
+ * Pure: it takes rows a store read already produced. No surface computes this
+ * itself, so the CLI and the dashboard cannot describe one total two ways.
+ */
+/**
+ * The parts a total can be made of, strongest first. Exact and family matches
+ * share a cost basis in the ledger (`local_list_price`), but a family match
+ * prices one model at another's rate, so the two are kept apart here.
+ */
+export const BASIS_COHORTS = [
+    'list_exact',
+    'list_family',
+    'user_declared',
+    'user_free',
+    'fallback',
+    'tool_reported',
+    'demo',
+    'unpriced',
+    'not_sent',
+    'unrecorded',
+];
+export const BASIS_BOUNDARY = 'None of these amounts is a provider bill. List price is what the use would cost at the provider\'s published API rates; a plan, discount, credit or tax is not in it.';
+const TEXT = {
+    list_exact: {
+        label: 'list price',
+        meaning: "priced at the model's own published API rate on the rate card",
+    },
+    list_family: {
+        label: 'list price, nearest model',
+        meaning: 'the model is not on the rate card by name; priced at the rate of the closest model that is',
+    },
+    user_declared: {
+        label: 'your price',
+        meaning: 'a price you set with segreant pricing set; Segreant has not checked it against a price list',
+    },
+    user_free: {
+        label: 'free, your setting',
+        meaning: 'a model you marked free with segreant pricing set --free (a local model); every request costs nothing',
+    },
+    fallback: {
+        label: 'fallback rate',
+        meaning: 'the model is not on the rate card; priced at a generic mid-tier rate, a rough estimate',
+    },
+    tool_reported: {
+        label: 'tool-reported',
+        meaning: 'the amount the tool itself recorded; Segreant has not verified it against any rate card or bill',
+    },
+    demo: {
+        label: 'sample data',
+        meaning: 'synthetic demo data, not measured on this machine',
+    },
+    unpriced: {
+        label: 'not priced',
+        meaning: 'no rate applies (for example a custom provider); counted in requests, not in dollars',
+    },
+    not_sent: {
+        label: 'refused, not sent',
+        meaning: 'stopped by Segreant before it reached the provider (a cap or an egress rule); nothing was charged',
+    },
+    unrecorded: {
+        label: 'basis not recorded',
+        meaning: 'recorded before Segreant kept how each amount was priced',
+    },
+};
+export function cohortOf(row) {
+    switch (row.costBasis) {
+        case 'local_list_price':
+            return row.rateMatchKind === 'exact_provider' || row.rateMatchKind === 'exact_cross_provider'
+                ? 'list_exact'
+                : 'list_family';
+        case 'fallback_estimate': return 'fallback';
+        case 'user_declared_price': return row.rateMatchKind === 'user_declared_free' ? 'user_free' : 'user_declared';
+        case 'tool_reported_unverified': return 'tool_reported';
+        case 'synthetic_demo': return 'demo';
+        case 'unpriced': return 'unpriced';
+        case 'not_sent': return 'not_sent';
+        default: return 'unrecorded';
+    }
+}
+export function summarizeBasis(rows) {
+    const by = new Map();
+    let totalUsd = 0;
+    let requests = 0;
+    for (const row of rows) {
+        if (row.requests <= 0)
+            continue;
+        const id = cohortOf(row);
+        let c = by.get(id);
+        if (!c) {
+            c = { id, costUsd: 0, requests: 0, ...TEXT[id], models: [] };
+            by.set(id, c);
+        }
+        c.costUsd += row.costUsd;
+        c.requests += row.requests;
+        const m = c.models.find((x) => x.provider === row.provider && x.model === row.model);
+        if (m) {
+            m.costUsd += row.costUsd;
+            m.requests += row.requests;
+        }
+        else {
+            c.models.push({ provider: row.provider, model: row.model, costUsd: row.costUsd, requests: row.requests });
+        }
+        totalUsd += row.costUsd;
+        requests += row.requests;
+    }
+    const cohorts = BASIS_COHORTS.flatMap((id) => {
+        const c = by.get(id);
+        if (!c)
+            return [];
+        c.models.sort((a, b) => b.costUsd - a.costUsd || b.requests - a.requests);
+        c.models = c.models.slice(0, 5);
+        return [c];
+    });
+    const has = (id) => by.has(id);
+    // Refused requests carry no money, so they never decide what the total is called.
+    const priced = cohorts.filter((c) => c.id !== 'not_sent');
+    const only = (...ids) => priced.length > 0 && priced.every((c) => ids.includes(c.id));
+    const headline = priced.length === 0
+        ? 'no_cost'
+        : only('demo')
+            ? 'sample_cost'
+            : only('tool_reported', 'unpriced') && has('tool_reported')
+                ? 'tool_reported_cost'
+                // A model marked free does not turn list prices into an estimate; any
+                // paid declaration does, whatever its amount, because the declaration
+                // itself is retained, not inferred from a zero (PR #146 review).
+                : only('list_exact', 'list_family', 'unpriced', 'user_free') && (has('list_exact') || has('list_family'))
+                    ? 'list_cost'
+                    : 'estimated_cost';
+    const exact = by.get('list_exact')?.costUsd ?? 0;
+    return {
+        totalUsd,
+        requests,
+        headline,
+        headlineLabel: HEADLINE_LABEL[headline],
+        cohorts,
+        exactShare: totalUsd > 0 ? exact / totalUsd : null,
+        boundary: BASIS_BOUNDARY,
+    };
+}
+const HEADLINE_LABEL = {
+    list_cost: 'List cost',
+    estimated_cost: 'Estimated cost',
+    sample_cost: 'Sample cost',
+    tool_reported_cost: 'Tool-reported cost',
+    no_cost: 'Cost',
+};
+/** "gpt-6.1-sol, codex-auto-review and 2 more" — the models a cohort holds, for one line of text. */
+export function cohortModels(c, shown = 2) {
+    const names = c.models.map((m) => m.model);
+    if (names.length <= shown)
+        return names.join(', ');
+    return `${names.slice(0, shown).join(', ')} and ${names.length - shown} more`;
+}